sig
  module Make :
    functor (Node : Regular.Std.Opaque.S) (Edge : Core_kernel.T) ->
      sig
        type t
        type node = Node.t
        type edge
        module Node :
          sig
            type t = node
            type graph = t
            type label = t
            type edge = edge
            val create : label -> label
            val label : label -> label
            val mem : label -> graph -> bool
            val succs : label -> graph -> label Regular.Std.seq
            val preds : label -> graph -> label Regular.Std.seq
            val inputs : label -> graph -> edge Regular.Std.seq
            val outputs : label -> graph -> edge Regular.Std.seq
            val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
            val insert : label -> graph -> graph
            val update : label -> label -> graph -> graph
            val remove : label -> graph -> graph
            val has_edge : label -> label -> graph -> bool
            val edge : label -> label -> graph -> edge option
            val ( >= ) : label -> label -> bool
            val ( <= ) : label -> label -> bool
            val ( = ) : label -> label -> bool
            val ( > ) : label -> label -> bool
            val ( < ) : label -> label -> bool
            val ( <> ) : label -> label -> bool
            val equal : label -> label -> bool
            val min : label -> label -> label
            val max : label -> label -> label
            val ascending : label -> label -> int
            val descending : label -> label -> int
            val between : label -> low:label -> high:label -> bool
            val clamp_exn : label -> min:label -> max:label -> label
            val clamp :
              label -> min:label -> max:label -> label Base__.Or_error.t
            type comparator_witness
            val comparator :
              (label, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:label Base__.Maybe_bound.t -> label Base__.Validate.check
            val validate_ubound :
              max:label Base__.Maybe_bound.t -> label Base__.Validate.check
            val validate_bound :
              min:label Base__.Maybe_bound.t ->
              max:label Base__.Maybe_bound.t -> label Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : label -> label -> bool
                val ( <= ) : label -> label -> bool
                val ( = ) : label -> label -> bool
                val ( > ) : label -> label -> bool
                val ( < ) : label -> label -> bool
                val ( <> ) : label -> label -> bool
                val equal : label -> label -> bool
                val compare : label -> label -> int
                val min : label -> label -> label
                val max : label -> label -> label
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = label
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (label, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : label -> 'a -> 'a t
                    val of_alist :
                      (label * 'a) list ->
                      [ `Duplicate_key of label | `Ok of 'a t ]
                    val of_alist_or_error :
                      (label * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (label * 'a) list -> 'a t
                    val of_alist_multi : (label * 'a) list -> 'a list t
                    val of_alist_fold :
                      (label * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (label * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (label * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> label * 'a) -> 'a t
                    val of_increasing_sequence :
                      (label * 'a) Base__.Sequence.t ->
                      'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of label | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (label, 'a) Core_kernel__.Hashtbl.t -> 'a t
                    val gen :
                      label Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:label ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:label -> data:'a -> 'a t
                    val set : 'a t -> key:label -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:label -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> label -> 'a list t
                    val find_multi : 'a list t -> label -> 'a list
                    val change :
                      'a t -> label -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> label -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> label -> 'a option
                    val find_exn : 'a t -> label -> 'a
                    val remove : 'a t -> label -> 'a t
                    val mem : 'a t -> label -> bool
                    val iter_keys : 'a t -> f:(label -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:label -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:label ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:label ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:label -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:label -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:label -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:label -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> label list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (label * 'a) list
                    val validate :
                      name:(label -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:label ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (label * 'a) option
                    val min_elt_exn : 'a t -> label * 'a
                    val max_elt : 'a t -> (label * 'a) option
                    val max_elt_exn : 'a t -> label * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:label -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:label -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:label -> data:'a -> bool) -> int
                    val split :
                      'a t -> label -> 'a t * (label * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:label Base__.Maybe_bound.t ->
                      upper_bound:label Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:label ->
                      max:label ->
                      init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:label -> max:label -> (label * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> label -> (label * 'a) option
                    val nth : 'a t -> int -> (label * 'a) option
                    val nth_exn : 'a t -> int -> label * 'a
                    val rank : 'a t -> label -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:label ->
                      ?keys_less_or_equal_to:label ->
                      'a t -> (label * 'a) Base__.Sequence.t
                    val obs :
                      label Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      label Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> label
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (label, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : label -> 'a -> 'a t
                val of_alist :
                  (label * 'a) list ->
                  [ `Duplicate_key of label | `Ok of 'a t ]
                val of_alist_or_error :
                  (label * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (label * 'a) list -> 'a t
                val of_alist_multi : (label * 'a) list -> 'a list t
                val of_alist_fold :
                  (label * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (label * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (label * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> label * 'a) -> 'a t
                val of_increasing_sequence :
                  (label * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of label | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn :
                  (label, 'a) Core_kernel__.Hashtbl.t -> 'a t
                val gen :
                  label Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:label -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:label -> data:'a -> 'a t
                val set : 'a t -> key:label -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:label -> data:'a -> 'a list t
                val remove_multi : 'a list t -> label -> 'a list t
                val find_multi : 'a list t -> label -> 'a list
                val change :
                  'a t -> label -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> label -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> label -> 'a option
                val find_exn : 'a t -> label -> 'a
                val remove : 'a t -> label -> 'a t
                val mem : 'a t -> label -> bool
                val iter_keys : 'a t -> f:(label -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:label -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:label ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:label ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:label -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:label -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:label -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:label -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> label list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (label * 'a) list
                val validate :
                  name:(label -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:label ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (label, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (label * 'a) option
                val min_elt_exn : 'a t -> label * 'a
                val max_elt : 'a t -> (label * 'a) option
                val max_elt_exn : 'a t -> label * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:label -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:label -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:label -> data:'a -> bool) -> int
                val split :
                  'a t -> label -> 'a t * (label * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:label Base__.Maybe_bound.t ->
                  upper_bound:label Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:label ->
                  max:label ->
                  init:'b -> f:(key:label -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:label -> max:label -> (label * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> label -> (label * 'a) option
                val nth : 'a t -> int -> (label * 'a) option
                val nth_exn : 'a t -> int -> label * 'a
                val rank : 'a t -> label -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:label ->
                  ?keys_less_or_equal_to:label ->
                  'a t -> (label * 'a) Base__.Sequence.t
                val obs :
                  label Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  label Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> label
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : label Bin_prot.Type_class.t
                             val bin_read_t : label Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> label)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               label Bin_prot.Type_class.reader
                             val bin_size_t : label Bin_prot.Size.sizer
                             val bin_write_t : label Bin_prot.Write.writer
                             val bin_writer_t :
                               label Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state ->
                               label -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = label
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (label, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (label, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(label -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> label -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(label -> bool) -> bool
                    val for_all : t -> f:(label -> bool) -> bool
                    val count : t -> f:(label -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(label -> 'sum) -> 'sum
                    val find : t -> f:(label -> bool) -> label option
                    val find_map : t -> f:(label -> 'a option) -> 'a option
                    val to_list : t -> label list
                    val to_array : t -> label array
                    val invariants : t -> bool
                    val mem : t -> label -> bool
                    val add : t -> label -> t
                    val remove : t -> label -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (label, label) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         label ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of label * label
                         | `Left of label
                         | `Right of label ] -> unit) ->
                      unit
                    val filter : t -> f:(label -> bool) -> t
                    val partition_tf : t -> f:(label -> bool) -> t * t
                    val elements : t -> label list
                    val min_elt : t -> label option
                    val min_elt_exn : t -> label
                    val max_elt : t -> label option
                    val max_elt_exn : t -> label
                    val choose : t -> label option
                    val choose_exn : t -> label
                    val split : t -> label -> t * label option * t
                    val group_by :
                      t -> equiv:(label -> label -> bool) -> t list
                    val find_exn : t -> f:(label -> bool) -> label
                    val find_index : t -> int -> label option
                    val nth : t -> int -> label option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:label ->
                      ?less_or_equal_to:label -> t -> label Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:label ->
                      ?less_or_equal_to:label ->
                      t ->
                      t ->
                      (label, label)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(label -> 'data) ->
                      (label, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      label Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      label Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : label -> t
                    val union_list : t list -> t
                    val of_list : label list -> t
                    val of_array : label array -> t
                    val of_sorted_array : label array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : label array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> label) -> t
                    val stable_dedup_list : label list -> label list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> label) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> label option) -> t
                    val of_tree : t -> t
                    val of_hash_set : label Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (label, 'a) Core_kernel__.Hashtbl.t -> t
                    val of_map_keys :
                      (label, 'a, comparator_witness) Core_kernel__.Map.t ->
                      t
                    val gen :
                      label Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> label
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (label, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (label, comparator_witness)
                    Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(label -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> label -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(label -> bool) -> bool
                val for_all : t -> f:(label -> bool) -> bool
                val count : t -> f:(label -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(label -> 'sum) -> 'sum
                val find : t -> f:(label -> bool) -> label option
                val find_map : t -> f:(label -> 'a option) -> 'a option
                val to_list : t -> label list
                val to_array : t -> label array
                val invariants : t -> bool
                val mem : t -> label -> bool
                val add : t -> label -> t
                val remove : t -> label -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (label, label) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     label -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of label * label
                     | `Left of label
                     | `Right of label ] -> unit) ->
                  unit
                val filter : t -> f:(label -> bool) -> t
                val partition_tf : t -> f:(label -> bool) -> t * t
                val elements : t -> label list
                val min_elt : t -> label option
                val min_elt_exn : t -> label
                val max_elt : t -> label option
                val max_elt_exn : t -> label
                val choose : t -> label option
                val choose_exn : t -> label
                val split : t -> label -> t * label option * t
                val group_by : t -> equiv:(label -> label -> bool) -> t list
                val find_exn : t -> f:(label -> bool) -> label
                val find_index : t -> int -> label option
                val nth : t -> int -> label option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:label ->
                  ?less_or_equal_to:label -> t -> label Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:label ->
                  ?less_or_equal_to:label ->
                  t ->
                  t ->
                  (label, label) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(label -> 'data) ->
                  (label, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  label Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  label Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : label -> t
                val union_list : t list -> t
                val of_list : label list -> t
                val of_array : label array -> t
                val of_sorted_array : label array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : label array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> label) -> t
                val stable_dedup_list : label list -> label list
                val map : ('a, 'b) Base.Set.t -> f:('a -> label) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> label option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : label Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys :
                  (label, 'a) Core_kernel__.Hashtbl.t -> t
                val of_map_keys :
                  (label, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  label Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> label
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : label Bin_prot.Type_class.t
                             val bin_read_t : label Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> label)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               label Bin_prot.Type_class.reader
                             val bin_size_t : label Bin_prot.Size.sizer
                             val bin_write_t : label Bin_prot.Write.writer
                             val bin_writer_t :
                               label Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state ->
                               label -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : label -> label -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state ->
              label -> Ppx_hash_lib.Std.Hash.state
            val hash : label -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : label Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = label
                type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = label
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = label
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> label -> Core_kernel__.Import.bool
                val lookup : 'a t -> label -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> label -> 'a
                val enqueue :
                  'a t -> label -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> label -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> label -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (label * 'a) Core_kernel__.Import.option
                val keys : 'a t -> label Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (label * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> label * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> label -> Core_kernel__.Import.unit
                val replace : 'a t -> label -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> label -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:label -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:label -> data:'a -> 'b) -> 'b
              end
          end
        module Edge :
          sig
            type t = edge
            type node = Node.t
            type graph = Node.graph
            type label = Edge.t
            val create : node -> node -> label -> t
            val label : t -> label
            val src : t -> node
            val dst : t -> node
            val mem : t -> graph -> bool
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : edge -> 'a -> 'a t
                    val of_alist :
                      (edge * 'a) list ->
                      [ `Duplicate_key of edge | `Ok of 'a t ]
                    val of_alist_or_error :
                      (edge * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (edge * 'a) list -> 'a t
                    val of_alist_multi : (edge * 'a) list -> 'a list t
                    val of_alist_fold :
                      (edge * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (edge * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge * 'a) -> 'a t
                    val of_increasing_sequence :
                      (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of edge | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (edge, 'a) Node.Table.hashtbl -> 'a t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:edge ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                    val set : 'a t -> key:edge -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:edge -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> edge -> 'a list t
                    val find_multi : 'a list t -> edge -> 'a list
                    val change :
                      'a t -> edge -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> edge -> 'a option
                    val find_exn : 'a t -> edge -> 'a
                    val remove : 'a t -> edge -> 'a t
                    val mem : 'a t -> edge -> bool
                    val iter_keys : 'a t -> f:(edge -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:edge -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> edge list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (edge * 'a) list
                    val validate :
                      name:(edge -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (edge * 'a) option
                    val min_elt_exn : 'a t -> edge * 'a
                    val max_elt : 'a t -> (edge * 'a) option
                    val max_elt_exn : 'a t -> edge * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:edge -> data:'a -> bool) -> int
                    val split :
                      'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:edge Base__.Maybe_bound.t ->
                      upper_bound:edge Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:edge ->
                      max:edge ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:edge -> max:edge -> (edge * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> edge -> (edge * 'a) option
                    val nth : 'a t -> int -> (edge * 'a) option
                    val nth_exn : 'a t -> int -> edge * 'a
                    val rank : 'a t -> edge -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:edge ->
                      ?keys_less_or_equal_to:edge ->
                      'a t -> (edge * 'a) Base__.Sequence.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : edge -> 'a -> 'a t
                val of_alist :
                  (edge * 'a) list ->
                  [ `Duplicate_key of edge | `Ok of 'a t ]
                val of_alist_or_error :
                  (edge * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (edge * 'a) list -> 'a t
                val of_alist_multi : (edge * 'a) list -> 'a list t
                val of_alist_fold :
                  (edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (edge * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge * 'a) -> 'a t
                val of_increasing_sequence :
                  (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of edge | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:edge -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                val set : 'a t -> key:edge -> data:'a -> 'a t
                val add_multi : 'a list t -> key:edge -> data:'a -> 'a list t
                val remove_multi : 'a list t -> edge -> 'a list t
                val find_multi : 'a list t -> edge -> 'a list
                val change :
                  'a t -> edge -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> edge -> 'a option
                val find_exn : 'a t -> edge -> 'a
                val remove : 'a t -> edge -> 'a t
                val mem : 'a t -> edge -> bool
                val iter_keys : 'a t -> f:(edge -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> edge list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (edge * 'a) list
                val validate :
                  name:(edge -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (edge * 'a) option
                val min_elt_exn : 'a t -> edge * 'a
                val max_elt : 'a t -> (edge * 'a) option
                val max_elt_exn : 'a t -> edge * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
                val split : 'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:edge Base__.Maybe_bound.t ->
                  upper_bound:edge Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:edge ->
                  max:edge ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:edge -> max:edge -> (edge * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> edge -> (edge * 'a) option
                val nth : 'a t -> int -> (edge * 'a) option
                val nth_exn : 'a t -> int -> edge * 'a
                val rank : 'a t -> edge -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:edge ->
                  ?keys_less_or_equal_to:edge ->
                  'a t -> (edge * 'a) Base__.Sequence.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(edge -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(edge -> bool) -> bool
                    val for_all : t -> f:(edge -> bool) -> bool
                    val count : t -> f:(edge -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(edge -> 'sum) -> 'sum
                    val find : t -> f:(edge -> bool) -> edge option
                    val find_map : t -> f:(edge -> 'a option) -> 'a option
                    val to_list : t -> edge list
                    val to_array : t -> edge array
                    val invariants : t -> bool
                    val mem : t -> edge -> bool
                    val add : t -> edge -> t
                    val remove : t -> edge -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         edge ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of edge * edge
                         | `Left of edge
                         | `Right of edge ] -> unit) ->
                      unit
                    val filter : t -> f:(edge -> bool) -> t
                    val partition_tf : t -> f:(edge -> bool) -> t * t
                    val elements : t -> edge list
                    val min_elt : t -> edge option
                    val min_elt_exn : t -> edge
                    val max_elt : t -> edge option
                    val max_elt_exn : t -> edge
                    val choose : t -> edge option
                    val choose_exn : t -> edge
                    val split : t -> edge -> t * edge option * t
                    val group_by :
                      t -> equiv:(edge -> edge -> bool) -> t list
                    val find_exn : t -> f:(edge -> bool) -> edge
                    val find_index : t -> int -> edge option
                    val nth : t -> int -> edge option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge ->
                      t ->
                      t ->
                      (edge, edge)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(edge -> 'data) ->
                      (edge, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : edge -> t
                    val union_list : t list -> t
                    val of_list : edge list -> t
                    val of_array : edge array -> t
                    val of_sorted_array : edge array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : edge array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge) -> t
                    val stable_dedup_list : edge list -> edge list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge option) -> t
                    val of_tree : t -> t
                    val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                    val of_map_keys :
                      (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (edge, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (edge, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(edge -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(edge -> bool) -> bool
                val for_all : t -> f:(edge -> bool) -> bool
                val count : t -> f:(edge -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(edge -> 'sum) -> 'sum
                val find : t -> f:(edge -> bool) -> edge option
                val find_map : t -> f:(edge -> 'a option) -> 'a option
                val to_list : t -> edge list
                val to_array : t -> edge array
                val invariants : t -> bool
                val mem : t -> edge -> bool
                val add : t -> edge -> t
                val remove : t -> edge -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     edge -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of edge * edge | `Left of edge | `Right of edge ] ->
                     unit) ->
                  unit
                val filter : t -> f:(edge -> bool) -> t
                val partition_tf : t -> f:(edge -> bool) -> t * t
                val elements : t -> edge list
                val min_elt : t -> edge option
                val min_elt_exn : t -> edge
                val max_elt : t -> edge option
                val max_elt_exn : t -> edge
                val choose : t -> edge option
                val choose_exn : t -> edge
                val split : t -> edge -> t * edge option * t
                val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                val find_exn : t -> f:(edge -> bool) -> edge
                val find_index : t -> int -> edge option
                val nth : t -> int -> edge option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge ->
                  t ->
                  t ->
                  (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(edge -> 'data) ->
                  (edge, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : edge -> t
                val union_list : t list -> t
                val of_list : edge list -> t
                val of_array : edge array -> t
                val of_sorted_array : edge array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : edge array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge) -> t
                val stable_dedup_list : edge list -> edge list
                val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                val of_map_keys :
                  (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = edge
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> edge -> Core_kernel__.Import.bool
                val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> edge -> 'a
                val enqueue :
                  'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val keys : 'a t -> edge Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> edge * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
              end
          end
        val empty : t
        val nodes : t -> node Regular.Std.seq
        val edges : t -> edge Regular.Std.seq
        val is_directed : bool
        val number_of_edges : t -> int
        val number_of_nodes : t -> int
        val ( >= ) : t -> t -> bool
        val ( <= ) : t -> t -> bool
        val ( = ) : t -> t -> bool
        val ( > ) : t -> t -> bool
        val ( < ) : t -> t -> bool
        val ( <> ) : t -> t -> bool
        val equal : t -> t -> bool
        val min : t -> t -> t
        val max : t -> t -> t
        val ascending : t -> t -> int
        val descending : t -> t -> int
        val between : t -> low:t -> high:t -> bool
        val clamp_exn : t -> min:t -> max:t -> t
        val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
        type comparator_witness
        val comparator : (t, comparator_witness) Base__.Comparator.comparator
        val validate_lbound :
          min:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_ubound :
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_bound :
          min:t Base__.Maybe_bound.t ->
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        module Replace_polymorphic_compare :
          sig
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val min : t -> t -> t
            val max : t -> t -> t
          end
        module Map :
          sig
            module Key :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type 'a t =
                    (Key.t, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Key.t * 'a) -> 'a t
                val of_increasing_sequence :
                  (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of Key.t | `Ok of 'v t ]
                val of_tree : 'a t -> 'a t
                val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                val gen :
                  Key.t Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
                val set : 'a t -> key:Key.t -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> 'a list t
                val remove_multi : 'a list t -> Key.t -> 'a list t
                val find_multi : 'a list t -> Key.t -> 'a list
                val change :
                  'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:Key.t Base__.Maybe_bound.t ->
                  upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val nth_exn : 'a t -> int -> Key.t * 'a
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Base__.Sequence.t
                val obs :
                  Key.t Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (K : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type 'a t =
                (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
            val compare :
              ('a -> 'a -> Core_kernel__.Import.int) ->
              'a t -> 'a t -> Core_kernel__.Import.int
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_or_error :
              (Key.t * 'a) list -> 'a t Base__.Or_error.t
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_alist_reduce :
              (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
            val of_sorted_array :
              (Key.t * 'a) array -> 'a t Base__.Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Key.t * 'a) -> 'a t
            val of_increasing_sequence :
              (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
            val of_iteri :
              iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
              [ `Duplicate_key of Key.t | `Ok of 'v t ]
            val of_tree : 'a Tree.t -> 'a t
            val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
            val gen :
              Key.t Core_kernel__.Quickcheck.Generator.t ->
              'a Core_kernel__.Quickcheck.Generator.t ->
              'a t Core_kernel__.Quickcheck.Generator.t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add :
              'a t ->
              key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
            val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
            val set : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val remove_multi : 'a list t -> Key.t -> 'a list t
            val find_multi : 'a list t -> Key.t -> 'a list
            val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
            val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
            val iter : 'a t -> f:('a -> unit) -> unit
            val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold2 :
              'a t ->
              'b t ->
              init:'c ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c -> 'c) ->
              'c
            val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
            val filter : 'a t -> f:('a -> bool) -> 'a t
            val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val partition_mapi :
              'a t ->
              f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
              'b t * 'c t
            val partition_map :
              'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
            val partitioni_tf :
              'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
            val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist :
              ?key_order:[ `Decreasing | `Increasing ] ->
              'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Base__.Validate.check -> 'a t Base__.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
              Base__.Sequence.t
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
            val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
            val append :
              lower_part:'a t ->
              upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
            val subrange :
              'a t ->
              lower_bound:Key.t Base__.Maybe_bound.t ->
              upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val closest_key :
              'a t ->
              [ `Greater_or_equal_to
              | `Greater_than
              | `Less_or_equal_to
              | `Less_than ] -> Key.t -> (Key.t * 'a) option
            val nth : 'a t -> int -> (Key.t * 'a) option
            val nth_exn : 'a t -> int -> Key.t * 'a
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val to_sequence :
              ?order:[ `Decreasing_key | `Increasing_key ] ->
              ?keys_greater_or_equal_to:Key.t ->
              ?keys_less_or_equal_to:Key.t ->
              'a t -> (Key.t * 'a) Base__.Sequence.t
            val obs :
              Key.t Core_kernel__.Quickcheck.Observer.t ->
              'v Core_kernel__.Quickcheck.Observer.t ->
              'v t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Key.t Core_kernel__.Quickcheck.Shrinker.t ->
              'v Core_kernel__.Quickcheck.Shrinker.t ->
              'v t Core_kernel__.Quickcheck.Shrinker.t
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : Key.t Bin_prot.Type_class.t
                         val bin_read_t : Key.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Key.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Key.t Bin_prot.Type_class.reader
                         val bin_size_t : Key.t Bin_prot.Size.sizer
                         val bin_write_t : Key.t Bin_prot.Write.writer
                         val bin_writer_t : Key.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
            module Provide_hash :
              functor
                (Key : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Key.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    (Ppx_hash_lib.Std.Hash.state ->
                     'a -> Ppx_hash_lib.Std.Hash.state) ->
                    Ppx_hash_lib.Std.Hash.state ->
                    'a t -> Ppx_hash_lib.Std.Hash.state
                end
            val t_of_sexp :
              (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        module Set :
          sig
            module Elt :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = Map.Key.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type t =
                    (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (Elt.t, comparator_witness)
                    Core_kernel__.Set_intf.Tree.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val nth : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t ->
                  t ->
                  (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  Elt.t Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Elt.t) -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t option) -> t
                val of_tree : t -> t
                val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                val of_map_keys :
                  (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  Elt.t Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type t = (Elt.t, comparator_witness) Base.Set.t
            val compare : t -> t -> Core_kernel__.Import.int
            type named =
                (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
            val length : t -> int
            val is_empty : t -> bool
            val iter : t -> f:(Elt.t -> unit) -> unit
            val fold :
              t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
            val fold_result :
              t ->
              init:'accum ->
              f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val exists : t -> f:(Elt.t -> bool) -> bool
            val for_all : t -> f:(Elt.t -> bool) -> bool
            val count : t -> f:(Elt.t -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              t -> f:(Elt.t -> 'sum) -> 'sum
            val find : t -> f:(Elt.t -> bool) -> Elt.t option
            val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
            val to_list : t -> Elt.t list
            val to_array : t -> Elt.t array
            val invariants : t -> bool
            val mem : t -> Elt.t -> bool
            val add : t -> Elt.t -> t
            val remove : t -> Elt.t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val symmetric_diff :
              t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
            val compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val is_subset : t -> of_:t -> bool
            val subset : t -> t -> bool
            module Named :
              sig
                val is_subset : named -> of_:named -> unit Base__.Or_error.t
                val equal : named -> named -> unit Base__.Or_error.t
              end
            val fold_until :
              t ->
              init:'b ->
              f:('b ->
                 Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
              finish:('b -> 'final) -> 'final
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
            val iter2 :
              t ->
              t ->
              f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
                 unit) ->
              unit
            val filter : t -> f:(Elt.t -> bool) -> t
            val partition_tf : t -> f:(Elt.t -> bool) -> t * t
            val elements : t -> Elt.t list
            val min_elt : t -> Elt.t option
            val min_elt_exn : t -> Elt.t
            val max_elt : t -> Elt.t option
            val max_elt_exn : t -> Elt.t
            val choose : t -> Elt.t option
            val choose_exn : t -> Elt.t
            val split : t -> Elt.t -> t * Elt.t option * t
            val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
            val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
            val find_index : t -> int -> Elt.t option
            val nth : t -> int -> Elt.t option
            val remove_index : t -> int -> t
            val to_tree : t -> Tree.t
            val to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
            val merge_to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t ->
              t ->
              t ->
              (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
              Base__.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
            val obs :
              Elt.t Core_kernel__.Quickcheck.Observer.t ->
              t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
              t Core_kernel__.Quickcheck.Shrinker.t
            val empty : t
            val singleton : Elt.t -> t
            val union_list : t list -> t
            val of_list : Elt.t list -> t
            val of_array : Elt.t array -> t
            val of_sorted_array : Elt.t array -> t Base__.Or_error.t
            val of_sorted_array_unchecked : Elt.t array -> t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Elt.t) -> t
            val stable_dedup_list : Elt.t list -> Elt.t list
            val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
            val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
            val of_map_keys :
              (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
            val gen :
              Elt.t Core_kernel__.Quickcheck.Generator.t ->
              t Core_kernel__.Quickcheck.Generator.t
            module Provide_of_sexp :
              functor
                (Elt : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                       end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (Elt : sig
                         val bin_t : Elt.t Bin_prot.Type_class.t
                         val bin_read_t : Elt.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Elt.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                         val bin_size_t : Elt.t Bin_prot.Size.sizer
                         val bin_write_t : Elt.t Bin_prot.Write.writer
                         val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
            module Provide_hash :
              functor
                (Elt : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Elt.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                end
            val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
            val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        val compare : t -> t -> Core_kernel__.Import.int
        val hash_fold_t :
          Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
        val hashable : t Core_kernel__.Hashtbl.Hashable.t
        module Table :
          sig
            type key = t
            type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
            type 'b t = (key, 'b) hashtbl
            val sexp_of_t :
              ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
              'b t -> Ppx_sexp_conv_lib.Sexp.t
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
            val invariant :
              'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
            val create :
              (key, 'b, unit -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist :
              (key, 'b,
               (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              (key, 'b,
               (key * 'b) list ->
               [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_or_error :
              (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              (key, 'b, (key * 'b) list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              (key, 'b list, (key * 'b) list -> 'b list t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_mapped :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key :
              (key, 'r,
               get_key:('r -> key) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_or_error :
              (key, 'r,
               get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val group :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val sexp_of_key : 'a t -> key -> Base__.Sexp.t
            val clear : 'a t -> unit
            val copy : 'b t -> 'b t
            val fold :
              'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
            val iter_keys : 'a t -> f:(key -> unit) -> unit
            val iter : 'b t -> f:('b -> unit) -> unit
            val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
            val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val exists : 'b t -> f:('b -> bool) -> bool
            val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val for_all : 'b t -> f:('b -> bool) -> bool
            val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
            val count : 'b t -> f:('b -> bool) -> int
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val mem : 'a t -> key -> bool
            val remove : 'a t -> key -> unit
            val set : 'b t -> key:key -> data:'b -> unit
            val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : 'b t -> key:key -> data:'b -> unit
            val change : 'b t -> key -> f:('b option -> 'b option) -> unit
            val update : 'b t -> key -> f:('b option -> 'b) -> unit
            val map : 'b t -> f:('b -> 'c) -> 'c t
            val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
            val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
            val filter_mapi :
              'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
            val filter_keys : 'b t -> f:(key -> bool) -> 'b t
            val filter : 'b t -> f:('b -> bool) -> 'b t
            val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
            val partition_map :
              'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
            val partition_mapi :
              'b t ->
              f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              'c t * 'd t
            val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
            val partitioni_tf :
              'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
            val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
            val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
            val find : 'b t -> key -> 'b option
            val find_exn : 'b t -> key -> 'b
            val find_and_call :
              'b t ->
              key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
            val findi_and_call :
              'b t ->
              key ->
              if_found:(key:key -> data:'b -> 'c) ->
              if_not_found:(key -> 'c) -> 'c
            val find_and_remove : 'b t -> key -> 'b option
            val merge :
              'a t ->
              'b t ->
              f:(key:key ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            type 'a merge_into_action = Remove | Set_to of 'a
            val merge_into :
              src:'a t ->
              dst:'b t ->
              f:(key:key -> 'a -> 'b option -> 'b merge_into_action) -> unit
            val keys : 'a t -> key list
            val data : 'b t -> 'b list
            val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
            val filter_inplace : 'b t -> f:('b -> bool) -> unit
            val filteri_inplace :
              'b t -> f:(key:key -> data:'b -> bool) -> unit
            val map_inplace : 'b t -> f:('b -> 'b) -> unit
            val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
            val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
            val filter_mapi_inplace :
              'b t -> f:(key:key -> data:'b -> 'b option) -> unit
            val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
            val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
            val to_alist : 'b t -> (key * 'b) list
            val validate :
              name:(key -> string) ->
              'b Base__.Validate.check -> 'b t Base__.Validate.check
            val incr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val decr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val add_multi : 'b list t -> key:key -> data:'b -> unit
            val remove_multi : 'a list t -> key -> unit
            val find_multi : 'b list t -> key -> 'b list
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : key Bin_prot.Type_class.t
                         val bin_read_t : key Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> key)
                           Bin_prot.Read.reader
                         val bin_reader_t : key Bin_prot.Type_class.reader
                         val bin_size_t : key Bin_prot.Size.sizer
                         val bin_write_t : key Bin_prot.Write.writer
                         val bin_writer_t : key Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_t :
                    'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                  val bin_read_t :
                    'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'a Bin_prot.Read.reader ->
                    (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                  val bin_reader_t :
                    'a Bin_prot.Type_class.reader ->
                    'a t Bin_prot.Type_class.reader
                  val bin_size_t :
                    'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                  val bin_write_t :
                    'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                  val bin_writer_t :
                    'a Bin_prot.Type_class.writer ->
                    'a t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                end
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          end
        module Hash_set :
          sig
            type elt = t
            type t = elt Core_kernel__.Hash_set.t
            val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            val of_list :
              ('a, elt list -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            module Provide_of_sexp :
              functor
                (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (X : sig
                       val bin_t : elt Bin_prot.Type_class.t
                       val bin_read_t : elt Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> elt)
                         Bin_prot.Read.reader
                       val bin_reader_t : elt Bin_prot.Type_class.reader
                       val bin_size_t : elt Bin_prot.Size.sizer
                       val bin_write_t : elt Bin_prot.Write.writer
                       val bin_writer_t : elt Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end) ->
                sig
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                end
            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          end
        module Hash_queue :
          sig
            module Key :
              sig
                type t = Hash_set.elt
                val compare : t -> t -> int
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                val hash : t -> int
              end
            type 'a t
            val sexp_of_t :
              ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('a -> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 'a ->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('a -> bool) -> bool
            val for_all : 'a t -> f:('a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('a -> 'sum) -> 'sum
            val find : 'a t -> f:('a -> bool) -> 'a option
            val find_map : 'a t -> f:('a -> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val invariant : 'a t -> Core_kernel__.Import.unit
            val create :
              ?growth_allowed:Core_kernel__.Import.bool ->
              ?size:Core_kernel__.Import.int ->
              Core_kernel__.Import.unit -> 'a t
            val clear : 'a t -> Core_kernel__.Import.unit
            val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
            val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_exn : 'a t -> Key.t -> 'a
            val enqueue :
              'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
            val enqueue_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val lookup_and_move_to_back :
              'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
            val first : 'a t -> 'a Core_kernel__.Import.option
            val first_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val keys : 'a t -> Key.t Core_kernel__.Import.list
            val dequeue : 'a t -> 'a Core_kernel__.Import.option
            val dequeue_exn : 'a t -> 'a
            val dequeue_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val dequeue_with_key_exn : 'a t -> Key.t * 'a
            val dequeue_all :
              'a t ->
              f:('a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
            val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
            val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
            val replace_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val iteri :
              'a t ->
              f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val foldi :
              'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
          end
        val to_string : t -> string
        val str : unit -> t -> string
        val pps : unit -> t -> string
        val ppo : Core_kernel.Out_channel.t -> t -> unit
        val pp_seq : Format.formatter -> t Core_kernel.Sequence.t -> unit
        val pp : Base__.Formatter.t -> t -> unit
      end
  module Labeled :
    functor
      (Node : Regular.Std.Opaque.S) (NL : Core_kernel.T) (EL : Core_kernel.T) ->
      sig
        type t
        type node = (Node.t, NL.t) labeled
        type edge
        module Node :
          sig
            type t = node
            type graph = t
            type label = (Node.t, NL.t) labeled
            type edge = edge
            val create : label -> t
            val label : t -> label
            val mem : t -> graph -> bool
            val succs : t -> graph -> t Regular.Std.seq
            val preds : t -> graph -> t Regular.Std.seq
            val inputs : t -> graph -> edge Regular.Std.seq
            val outputs : t -> graph -> edge Regular.Std.seq
            val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val has_edge : t -> t -> graph -> bool
            val edge : t -> t -> graph -> edge option
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (node, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : node -> 'a -> 'a t
                    val of_alist :
                      (node * 'a) list ->
                      [ `Duplicate_key of node | `Ok of 'a t ]
                    val of_alist_or_error :
                      (node * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (node * 'a) list -> 'a t
                    val of_alist_multi : (node * 'a) list -> 'a list t
                    val of_alist_fold :
                      (node * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (node * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node * 'a) -> 'a t
                    val of_increasing_sequence :
                      (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of node | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:node ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:node -> data:'a -> 'a t
                    val set : 'a t -> key:node -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:node -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> node -> 'a list t
                    val find_multi : 'a list t -> node -> 'a list
                    val change :
                      'a t -> node -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> node -> 'a option
                    val find_exn : 'a t -> node -> 'a
                    val remove : 'a t -> node -> 'a t
                    val mem : 'a t -> node -> bool
                    val iter_keys : 'a t -> f:(node -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:node -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> node list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (node * 'a) list
                    val validate :
                      name:(node -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (node * 'a) option
                    val min_elt_exn : 'a t -> node * 'a
                    val max_elt : 'a t -> (node * 'a) option
                    val max_elt_exn : 'a t -> node * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:node -> data:'a -> bool) -> int
                    val split :
                      'a t -> node -> 'a t * (node * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:node Base__.Maybe_bound.t ->
                      upper_bound:node Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:node ->
                      max:node ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:node -> max:node -> (node * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> node -> (node * 'a) option
                    val nth : 'a t -> int -> (node * 'a) option
                    val nth_exn : 'a t -> int -> node * 'a
                    val rank : 'a t -> node -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:node ->
                      ?keys_less_or_equal_to:node ->
                      'a t -> (node * 'a) Base__.Sequence.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (node, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : node -> 'a -> 'a t
                val of_alist :
                  (node * 'a) list ->
                  [ `Duplicate_key of node | `Ok of 'a t ]
                val of_alist_or_error :
                  (node * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (node * 'a) list -> 'a t
                val of_alist_multi : (node * 'a) list -> 'a list t
                val of_alist_fold :
                  (node * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (node * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node * 'a) -> 'a t
                val of_increasing_sequence :
                  (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of node | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn :
                  (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:node -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:node -> data:'a -> 'a t
                val set : 'a t -> key:node -> data:'a -> 'a t
                val add_multi : 'a list t -> key:node -> data:'a -> 'a list t
                val remove_multi : 'a list t -> node -> 'a list t
                val find_multi : 'a list t -> node -> 'a list
                val change :
                  'a t -> node -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> node -> 'a option
                val find_exn : 'a t -> node -> 'a
                val remove : 'a t -> node -> 'a t
                val mem : 'a t -> node -> bool
                val iter_keys : 'a t -> f:(node -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:node -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> node list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (node * 'a) list
                val validate :
                  name:(node -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (node * 'a) option
                val min_elt_exn : 'a t -> node * 'a
                val max_elt : 'a t -> (node * 'a) option
                val max_elt_exn : 'a t -> node * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:node -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:node -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:node -> data:'a -> bool) -> int
                val split : 'a t -> node -> 'a t * (node * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:node Base__.Maybe_bound.t ->
                  upper_bound:node Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:node ->
                  max:node ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:node -> max:node -> (node * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> node -> (node * 'a) option
                val nth : 'a t -> int -> (node * 'a) option
                val nth_exn : 'a t -> int -> node * 'a
                val rank : 'a t -> node -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:node ->
                  ?keys_less_or_equal_to:node ->
                  'a t -> (node * 'a) Base__.Sequence.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(node -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(node -> bool) -> bool
                    val for_all : t -> f:(node -> bool) -> bool
                    val count : t -> f:(node -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(node -> 'sum) -> 'sum
                    val find : t -> f:(node -> bool) -> node option
                    val find_map : t -> f:(node -> 'a option) -> 'a option
                    val to_list : t -> node list
                    val to_array : t -> node array
                    val invariants : t -> bool
                    val mem : t -> node -> bool
                    val add : t -> node -> t
                    val remove : t -> node -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (node, node) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         node ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of node * node
                         | `Left of node
                         | `Right of node ] -> unit) ->
                      unit
                    val filter : t -> f:(node -> bool) -> t
                    val partition_tf : t -> f:(node -> bool) -> t * t
                    val elements : t -> node list
                    val min_elt : t -> node option
                    val min_elt_exn : t -> node
                    val max_elt : t -> node option
                    val max_elt_exn : t -> node
                    val choose : t -> node option
                    val choose_exn : t -> node
                    val split : t -> node -> t * node option * t
                    val group_by :
                      t -> equiv:(node -> node -> bool) -> t list
                    val find_exn : t -> f:(node -> bool) -> node
                    val find_index : t -> int -> node option
                    val nth : t -> int -> node option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node ->
                      t ->
                      t ->
                      (node, node)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(node -> 'data) ->
                      (node, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : node -> t
                    val union_list : t list -> t
                    val of_list : node list -> t
                    val of_array : node array -> t
                    val of_sorted_array : node array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : node array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node) -> t
                    val stable_dedup_list : node list -> node list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node option) -> t
                    val of_tree : t -> t
                    val of_hash_set : node Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (node, 'a) Core_kernel__.Hashtbl.t -> t
                    val of_map_keys :
                      (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (node, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (node, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(node -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(node -> bool) -> bool
                val for_all : t -> f:(node -> bool) -> bool
                val count : t -> f:(node -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(node -> 'sum) -> 'sum
                val find : t -> f:(node -> bool) -> node option
                val find_map : t -> f:(node -> 'a option) -> 'a option
                val to_list : t -> node list
                val to_array : t -> node array
                val invariants : t -> bool
                val mem : t -> node -> bool
                val add : t -> node -> t
                val remove : t -> node -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     node -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of node * node | `Left of node | `Right of node ] ->
                     unit) ->
                  unit
                val filter : t -> f:(node -> bool) -> t
                val partition_tf : t -> f:(node -> bool) -> t * t
                val elements : t -> node list
                val min_elt : t -> node option
                val min_elt_exn : t -> node
                val max_elt : t -> node option
                val max_elt_exn : t -> node
                val choose : t -> node option
                val choose_exn : t -> node
                val split : t -> node -> t * node option * t
                val group_by : t -> equiv:(node -> node -> bool) -> t list
                val find_exn : t -> f:(node -> bool) -> node
                val find_index : t -> int -> node option
                val nth : t -> int -> node option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node ->
                  t ->
                  t ->
                  (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(node -> 'data) ->
                  (node, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : node -> t
                val union_list : t list -> t
                val of_list : node list -> t
                val of_array : node array -> t
                val of_sorted_array : node array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : node array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node) -> t
                val stable_dedup_list : node list -> node list
                val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> node option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : node Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (node, 'a) Core_kernel__.Hashtbl.t -> t
                val of_map_keys :
                  (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = node
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> node -> Core_kernel__.Import.bool
                val lookup : 'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> node -> 'a
                val enqueue :
                  'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val keys : 'a t -> node Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> node * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                val replace : 'a t -> node -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
              end
          end
        module Edge :
          sig
            type t = edge
            type node = Node.t
            type graph = Node.graph
            type label = EL.t
            val create : node -> node -> label -> t
            val label : t -> label
            val src : t -> node
            val dst : t -> node
            val mem : t -> graph -> bool
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : edge -> 'a -> 'a t
                    val of_alist :
                      (edge * 'a) list ->
                      [ `Duplicate_key of edge | `Ok of 'a t ]
                    val of_alist_or_error :
                      (edge * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (edge * 'a) list -> 'a t
                    val of_alist_multi : (edge * 'a) list -> 'a list t
                    val of_alist_fold :
                      (edge * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (edge * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge * 'a) -> 'a t
                    val of_increasing_sequence :
                      (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of edge | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (edge, 'a) Node.Table.hashtbl -> 'a t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:edge ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                    val set : 'a t -> key:edge -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:edge -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> edge -> 'a list t
                    val find_multi : 'a list t -> edge -> 'a list
                    val change :
                      'a t -> edge -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> edge -> 'a option
                    val find_exn : 'a t -> edge -> 'a
                    val remove : 'a t -> edge -> 'a t
                    val mem : 'a t -> edge -> bool
                    val iter_keys : 'a t -> f:(edge -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:edge -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> edge list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (edge * 'a) list
                    val validate :
                      name:(edge -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (edge * 'a) option
                    val min_elt_exn : 'a t -> edge * 'a
                    val max_elt : 'a t -> (edge * 'a) option
                    val max_elt_exn : 'a t -> edge * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:edge -> data:'a -> bool) -> int
                    val split :
                      'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:edge Base__.Maybe_bound.t ->
                      upper_bound:edge Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:edge ->
                      max:edge ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:edge -> max:edge -> (edge * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> edge -> (edge * 'a) option
                    val nth : 'a t -> int -> (edge * 'a) option
                    val nth_exn : 'a t -> int -> edge * 'a
                    val rank : 'a t -> edge -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:edge ->
                      ?keys_less_or_equal_to:edge ->
                      'a t -> (edge * 'a) Base__.Sequence.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : edge -> 'a -> 'a t
                val of_alist :
                  (edge * 'a) list ->
                  [ `Duplicate_key of edge | `Ok of 'a t ]
                val of_alist_or_error :
                  (edge * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (edge * 'a) list -> 'a t
                val of_alist_multi : (edge * 'a) list -> 'a list t
                val of_alist_fold :
                  (edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (edge * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge * 'a) -> 'a t
                val of_increasing_sequence :
                  (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of edge | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:edge -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                val set : 'a t -> key:edge -> data:'a -> 'a t
                val add_multi : 'a list t -> key:edge -> data:'a -> 'a list t
                val remove_multi : 'a list t -> edge -> 'a list t
                val find_multi : 'a list t -> edge -> 'a list
                val change :
                  'a t -> edge -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> edge -> 'a option
                val find_exn : 'a t -> edge -> 'a
                val remove : 'a t -> edge -> 'a t
                val mem : 'a t -> edge -> bool
                val iter_keys : 'a t -> f:(edge -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> edge list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (edge * 'a) list
                val validate :
                  name:(edge -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (edge * 'a) option
                val min_elt_exn : 'a t -> edge * 'a
                val max_elt : 'a t -> (edge * 'a) option
                val max_elt_exn : 'a t -> edge * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
                val split : 'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:edge Base__.Maybe_bound.t ->
                  upper_bound:edge Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:edge ->
                  max:edge ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:edge -> max:edge -> (edge * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> edge -> (edge * 'a) option
                val nth : 'a t -> int -> (edge * 'a) option
                val nth_exn : 'a t -> int -> edge * 'a
                val rank : 'a t -> edge -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:edge ->
                  ?keys_less_or_equal_to:edge ->
                  'a t -> (edge * 'a) Base__.Sequence.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(edge -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(edge -> bool) -> bool
                    val for_all : t -> f:(edge -> bool) -> bool
                    val count : t -> f:(edge -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(edge -> 'sum) -> 'sum
                    val find : t -> f:(edge -> bool) -> edge option
                    val find_map : t -> f:(edge -> 'a option) -> 'a option
                    val to_list : t -> edge list
                    val to_array : t -> edge array
                    val invariants : t -> bool
                    val mem : t -> edge -> bool
                    val add : t -> edge -> t
                    val remove : t -> edge -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         edge ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of edge * edge
                         | `Left of edge
                         | `Right of edge ] -> unit) ->
                      unit
                    val filter : t -> f:(edge -> bool) -> t
                    val partition_tf : t -> f:(edge -> bool) -> t * t
                    val elements : t -> edge list
                    val min_elt : t -> edge option
                    val min_elt_exn : t -> edge
                    val max_elt : t -> edge option
                    val max_elt_exn : t -> edge
                    val choose : t -> edge option
                    val choose_exn : t -> edge
                    val split : t -> edge -> t * edge option * t
                    val group_by :
                      t -> equiv:(edge -> edge -> bool) -> t list
                    val find_exn : t -> f:(edge -> bool) -> edge
                    val find_index : t -> int -> edge option
                    val nth : t -> int -> edge option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge ->
                      t ->
                      t ->
                      (edge, edge)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(edge -> 'data) ->
                      (edge, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : edge -> t
                    val union_list : t list -> t
                    val of_list : edge list -> t
                    val of_array : edge array -> t
                    val of_sorted_array : edge array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : edge array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge) -> t
                    val stable_dedup_list : edge list -> edge list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge option) -> t
                    val of_tree : t -> t
                    val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                    val of_map_keys :
                      (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (edge, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (edge, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(edge -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(edge -> bool) -> bool
                val for_all : t -> f:(edge -> bool) -> bool
                val count : t -> f:(edge -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(edge -> 'sum) -> 'sum
                val find : t -> f:(edge -> bool) -> edge option
                val find_map : t -> f:(edge -> 'a option) -> 'a option
                val to_list : t -> edge list
                val to_array : t -> edge array
                val invariants : t -> bool
                val mem : t -> edge -> bool
                val add : t -> edge -> t
                val remove : t -> edge -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     edge -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of edge * edge | `Left of edge | `Right of edge ] ->
                     unit) ->
                  unit
                val filter : t -> f:(edge -> bool) -> t
                val partition_tf : t -> f:(edge -> bool) -> t * t
                val elements : t -> edge list
                val min_elt : t -> edge option
                val min_elt_exn : t -> edge
                val max_elt : t -> edge option
                val max_elt_exn : t -> edge
                val choose : t -> edge option
                val choose_exn : t -> edge
                val split : t -> edge -> t * edge option * t
                val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                val find_exn : t -> f:(edge -> bool) -> edge
                val find_index : t -> int -> edge option
                val nth : t -> int -> edge option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge ->
                  t ->
                  t ->
                  (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(edge -> 'data) ->
                  (edge, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : edge -> t
                val union_list : t list -> t
                val of_list : edge list -> t
                val of_array : edge array -> t
                val of_sorted_array : edge array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : edge array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge) -> t
                val stable_dedup_list : edge list -> edge list
                val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                val of_map_keys :
                  (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = edge
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> edge -> Core_kernel__.Import.bool
                val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> edge -> 'a
                val enqueue :
                  'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val keys : 'a t -> edge Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> edge * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
              end
          end
        val empty : t
        val nodes : t -> node Regular.Std.seq
        val edges : t -> edge Regular.Std.seq
        val is_directed : bool
        val number_of_edges : t -> int
        val number_of_nodes : t -> int
        val ( >= ) : t -> t -> bool
        val ( <= ) : t -> t -> bool
        val ( = ) : t -> t -> bool
        val ( > ) : t -> t -> bool
        val ( < ) : t -> t -> bool
        val ( <> ) : t -> t -> bool
        val equal : t -> t -> bool
        val min : t -> t -> t
        val max : t -> t -> t
        val ascending : t -> t -> int
        val descending : t -> t -> int
        val between : t -> low:t -> high:t -> bool
        val clamp_exn : t -> min:t -> max:t -> t
        val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
        type comparator_witness
        val comparator : (t, comparator_witness) Base__.Comparator.comparator
        val validate_lbound :
          min:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_ubound :
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_bound :
          min:t Base__.Maybe_bound.t ->
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        module Replace_polymorphic_compare :
          sig
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val min : t -> t -> t
            val max : t -> t -> t
          end
        module Map :
          sig
            module Key :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type 'a t =
                    (Key.t, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Key.t * 'a) -> 'a t
                val of_increasing_sequence :
                  (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of Key.t | `Ok of 'v t ]
                val of_tree : 'a t -> 'a t
                val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                val gen :
                  Key.t Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
                val set : 'a t -> key:Key.t -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> 'a list t
                val remove_multi : 'a list t -> Key.t -> 'a list t
                val find_multi : 'a list t -> Key.t -> 'a list
                val change :
                  'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:Key.t Base__.Maybe_bound.t ->
                  upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val nth_exn : 'a t -> int -> Key.t * 'a
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Base__.Sequence.t
                val obs :
                  Key.t Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (K : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type 'a t =
                (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
            val compare :
              ('a -> 'a -> Core_kernel__.Import.int) ->
              'a t -> 'a t -> Core_kernel__.Import.int
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_or_error :
              (Key.t * 'a) list -> 'a t Base__.Or_error.t
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_alist_reduce :
              (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
            val of_sorted_array :
              (Key.t * 'a) array -> 'a t Base__.Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Key.t * 'a) -> 'a t
            val of_increasing_sequence :
              (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
            val of_iteri :
              iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
              [ `Duplicate_key of Key.t | `Ok of 'v t ]
            val of_tree : 'a Tree.t -> 'a t
            val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
            val gen :
              Key.t Core_kernel__.Quickcheck.Generator.t ->
              'a Core_kernel__.Quickcheck.Generator.t ->
              'a t Core_kernel__.Quickcheck.Generator.t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add :
              'a t ->
              key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
            val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
            val set : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val remove_multi : 'a list t -> Key.t -> 'a list t
            val find_multi : 'a list t -> Key.t -> 'a list
            val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
            val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
            val iter : 'a t -> f:('a -> unit) -> unit
            val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold2 :
              'a t ->
              'b t ->
              init:'c ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c -> 'c) ->
              'c
            val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
            val filter : 'a t -> f:('a -> bool) -> 'a t
            val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val partition_mapi :
              'a t ->
              f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
              'b t * 'c t
            val partition_map :
              'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
            val partitioni_tf :
              'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
            val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist :
              ?key_order:[ `Decreasing | `Increasing ] ->
              'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Base__.Validate.check -> 'a t Base__.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
              Base__.Sequence.t
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
            val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
            val append :
              lower_part:'a t ->
              upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
            val subrange :
              'a t ->
              lower_bound:Key.t Base__.Maybe_bound.t ->
              upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val closest_key :
              'a t ->
              [ `Greater_or_equal_to
              | `Greater_than
              | `Less_or_equal_to
              | `Less_than ] -> Key.t -> (Key.t * 'a) option
            val nth : 'a t -> int -> (Key.t * 'a) option
            val nth_exn : 'a t -> int -> Key.t * 'a
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val to_sequence :
              ?order:[ `Decreasing_key | `Increasing_key ] ->
              ?keys_greater_or_equal_to:Key.t ->
              ?keys_less_or_equal_to:Key.t ->
              'a t -> (Key.t * 'a) Base__.Sequence.t
            val obs :
              Key.t Core_kernel__.Quickcheck.Observer.t ->
              'v Core_kernel__.Quickcheck.Observer.t ->
              'v t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Key.t Core_kernel__.Quickcheck.Shrinker.t ->
              'v Core_kernel__.Quickcheck.Shrinker.t ->
              'v t Core_kernel__.Quickcheck.Shrinker.t
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : Key.t Bin_prot.Type_class.t
                         val bin_read_t : Key.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Key.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Key.t Bin_prot.Type_class.reader
                         val bin_size_t : Key.t Bin_prot.Size.sizer
                         val bin_write_t : Key.t Bin_prot.Write.writer
                         val bin_writer_t : Key.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
            module Provide_hash :
              functor
                (Key : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Key.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    (Ppx_hash_lib.Std.Hash.state ->
                     'a -> Ppx_hash_lib.Std.Hash.state) ->
                    Ppx_hash_lib.Std.Hash.state ->
                    'a t -> Ppx_hash_lib.Std.Hash.state
                end
            val t_of_sexp :
              (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        module Set :
          sig
            module Elt :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = Map.Key.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type t =
                    (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (Elt.t, comparator_witness)
                    Core_kernel__.Set_intf.Tree.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val nth : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t ->
                  t ->
                  (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  Elt.t Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Elt.t) -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t option) -> t
                val of_tree : t -> t
                val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                val of_map_keys :
                  (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  Elt.t Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type t = (Elt.t, comparator_witness) Base.Set.t
            val compare : t -> t -> Core_kernel__.Import.int
            type named =
                (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
            val length : t -> int
            val is_empty : t -> bool
            val iter : t -> f:(Elt.t -> unit) -> unit
            val fold :
              t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
            val fold_result :
              t ->
              init:'accum ->
              f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val exists : t -> f:(Elt.t -> bool) -> bool
            val for_all : t -> f:(Elt.t -> bool) -> bool
            val count : t -> f:(Elt.t -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              t -> f:(Elt.t -> 'sum) -> 'sum
            val find : t -> f:(Elt.t -> bool) -> Elt.t option
            val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
            val to_list : t -> Elt.t list
            val to_array : t -> Elt.t array
            val invariants : t -> bool
            val mem : t -> Elt.t -> bool
            val add : t -> Elt.t -> t
            val remove : t -> Elt.t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val symmetric_diff :
              t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
            val compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val is_subset : t -> of_:t -> bool
            val subset : t -> t -> bool
            module Named :
              sig
                val is_subset : named -> of_:named -> unit Base__.Or_error.t
                val equal : named -> named -> unit Base__.Or_error.t
              end
            val fold_until :
              t ->
              init:'b ->
              f:('b ->
                 Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
              finish:('b -> 'final) -> 'final
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
            val iter2 :
              t ->
              t ->
              f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
                 unit) ->
              unit
            val filter : t -> f:(Elt.t -> bool) -> t
            val partition_tf : t -> f:(Elt.t -> bool) -> t * t
            val elements : t -> Elt.t list
            val min_elt : t -> Elt.t option
            val min_elt_exn : t -> Elt.t
            val max_elt : t -> Elt.t option
            val max_elt_exn : t -> Elt.t
            val choose : t -> Elt.t option
            val choose_exn : t -> Elt.t
            val split : t -> Elt.t -> t * Elt.t option * t
            val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
            val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
            val find_index : t -> int -> Elt.t option
            val nth : t -> int -> Elt.t option
            val remove_index : t -> int -> t
            val to_tree : t -> Tree.t
            val to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
            val merge_to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t ->
              t ->
              t ->
              (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
              Base__.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
            val obs :
              Elt.t Core_kernel__.Quickcheck.Observer.t ->
              t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
              t Core_kernel__.Quickcheck.Shrinker.t
            val empty : t
            val singleton : Elt.t -> t
            val union_list : t list -> t
            val of_list : Elt.t list -> t
            val of_array : Elt.t array -> t
            val of_sorted_array : Elt.t array -> t Base__.Or_error.t
            val of_sorted_array_unchecked : Elt.t array -> t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Elt.t) -> t
            val stable_dedup_list : Elt.t list -> Elt.t list
            val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
            val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
            val of_map_keys :
              (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
            val gen :
              Elt.t Core_kernel__.Quickcheck.Generator.t ->
              t Core_kernel__.Quickcheck.Generator.t
            module Provide_of_sexp :
              functor
                (Elt : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                       end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (Elt : sig
                         val bin_t : Elt.t Bin_prot.Type_class.t
                         val bin_read_t : Elt.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Elt.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                         val bin_size_t : Elt.t Bin_prot.Size.sizer
                         val bin_write_t : Elt.t Bin_prot.Write.writer
                         val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
            module Provide_hash :
              functor
                (Elt : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Elt.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                end
            val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
            val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        val compare : t -> t -> Core_kernel__.Import.int
        val hash_fold_t :
          Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
        val hashable : t Core_kernel__.Hashtbl.Hashable.t
        module Table :
          sig
            type key = t
            type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
            type 'b t = (key, 'b) hashtbl
            val sexp_of_t :
              ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
              'b t -> Ppx_sexp_conv_lib.Sexp.t
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
            val invariant :
              'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
            val create :
              (key, 'b, unit -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist :
              (key, 'b,
               (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              (key, 'b,
               (key * 'b) list ->
               [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_or_error :
              (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              (key, 'b, (key * 'b) list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              (key, 'b list, (key * 'b) list -> 'b list t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_mapped :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key :
              (key, 'r,
               get_key:('r -> key) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_or_error :
              (key, 'r,
               get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val group :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val sexp_of_key : 'a t -> key -> Base__.Sexp.t
            val clear : 'a t -> unit
            val copy : 'b t -> 'b t
            val fold :
              'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
            val iter_keys : 'a t -> f:(key -> unit) -> unit
            val iter : 'b t -> f:('b -> unit) -> unit
            val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
            val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val exists : 'b t -> f:('b -> bool) -> bool
            val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val for_all : 'b t -> f:('b -> bool) -> bool
            val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
            val count : 'b t -> f:('b -> bool) -> int
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val mem : 'a t -> key -> bool
            val remove : 'a t -> key -> unit
            val set : 'b t -> key:key -> data:'b -> unit
            val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : 'b t -> key:key -> data:'b -> unit
            val change : 'b t -> key -> f:('b option -> 'b option) -> unit
            val update : 'b t -> key -> f:('b option -> 'b) -> unit
            val map : 'b t -> f:('b -> 'c) -> 'c t
            val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
            val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
            val filter_mapi :
              'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
            val filter_keys : 'b t -> f:(key -> bool) -> 'b t
            val filter : 'b t -> f:('b -> bool) -> 'b t
            val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
            val partition_map :
              'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
            val partition_mapi :
              'b t ->
              f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              'c t * 'd t
            val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
            val partitioni_tf :
              'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
            val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
            val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
            val find : 'b t -> key -> 'b option
            val find_exn : 'b t -> key -> 'b
            val find_and_call :
              'b t ->
              key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
            val findi_and_call :
              'b t ->
              key ->
              if_found:(key:key -> data:'b -> 'c) ->
              if_not_found:(key -> 'c) -> 'c
            val find_and_remove : 'b t -> key -> 'b option
            val merge :
              'a t ->
              'b t ->
              f:(key:key ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            type 'a merge_into_action = Remove | Set_to of 'a
            val merge_into :
              src:'a t ->
              dst:'b t ->
              f:(key:key -> 'a -> 'b option -> 'b merge_into_action) -> unit
            val keys : 'a t -> key list
            val data : 'b t -> 'b list
            val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
            val filter_inplace : 'b t -> f:('b -> bool) -> unit
            val filteri_inplace :
              'b t -> f:(key:key -> data:'b -> bool) -> unit
            val map_inplace : 'b t -> f:('b -> 'b) -> unit
            val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
            val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
            val filter_mapi_inplace :
              'b t -> f:(key:key -> data:'b -> 'b option) -> unit
            val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
            val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
            val to_alist : 'b t -> (key * 'b) list
            val validate :
              name:(key -> string) ->
              'b Base__.Validate.check -> 'b t Base__.Validate.check
            val incr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val decr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val add_multi : 'b list t -> key:key -> data:'b -> unit
            val remove_multi : 'a list t -> key -> unit
            val find_multi : 'b list t -> key -> 'b list
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : key Bin_prot.Type_class.t
                         val bin_read_t : key Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> key)
                           Bin_prot.Read.reader
                         val bin_reader_t : key Bin_prot.Type_class.reader
                         val bin_size_t : key Bin_prot.Size.sizer
                         val bin_write_t : key Bin_prot.Write.writer
                         val bin_writer_t : key Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_t :
                    'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                  val bin_read_t :
                    'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'a Bin_prot.Read.reader ->
                    (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                  val bin_reader_t :
                    'a Bin_prot.Type_class.reader ->
                    'a t Bin_prot.Type_class.reader
                  val bin_size_t :
                    'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                  val bin_write_t :
                    'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                  val bin_writer_t :
                    'a Bin_prot.Type_class.writer ->
                    'a t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                end
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          end
        module Hash_set :
          sig
            type elt = t
            type t = elt Core_kernel__.Hash_set.t
            val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            val of_list :
              ('a, elt list -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            module Provide_of_sexp :
              functor
                (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (X : sig
                       val bin_t : elt Bin_prot.Type_class.t
                       val bin_read_t : elt Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> elt)
                         Bin_prot.Read.reader
                       val bin_reader_t : elt Bin_prot.Type_class.reader
                       val bin_size_t : elt Bin_prot.Size.sizer
                       val bin_write_t : elt Bin_prot.Write.writer
                       val bin_writer_t : elt Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end) ->
                sig
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                end
            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          end
        module Hash_queue :
          sig
            module Key :
              sig
                type t = Hash_set.elt
                val compare : t -> t -> int
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                val hash : t -> int
              end
            type 'a t
            val sexp_of_t :
              ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('a -> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 'a ->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('a -> bool) -> bool
            val for_all : 'a t -> f:('a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('a -> 'sum) -> 'sum
            val find : 'a t -> f:('a -> bool) -> 'a option
            val find_map : 'a t -> f:('a -> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val invariant : 'a t -> Core_kernel__.Import.unit
            val create :
              ?growth_allowed:Core_kernel__.Import.bool ->
              ?size:Core_kernel__.Import.int ->
              Core_kernel__.Import.unit -> 'a t
            val clear : 'a t -> Core_kernel__.Import.unit
            val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
            val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_exn : 'a t -> Key.t -> 'a
            val enqueue :
              'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
            val enqueue_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val lookup_and_move_to_back :
              'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
            val first : 'a t -> 'a Core_kernel__.Import.option
            val first_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val keys : 'a t -> Key.t Core_kernel__.Import.list
            val dequeue : 'a t -> 'a Core_kernel__.Import.option
            val dequeue_exn : 'a t -> 'a
            val dequeue_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val dequeue_with_key_exn : 'a t -> Key.t * 'a
            val dequeue_all :
              'a t ->
              f:('a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
            val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
            val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
            val replace_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val iteri :
              'a t ->
              f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val foldi :
              'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
          end
        val to_string : t -> string
        val str : unit -> t -> string
        val pps : unit -> t -> string
        val ppo : Core_kernel.Out_channel.t -> t -> unit
        val pp_seq : Format.formatter -> t Core_kernel.Sequence.t -> unit
        val pp : Base__.Formatter.t -> t -> unit
      end
  val create :
    (module Graphlib.Std.Graph with type t = 'c and type Edge.label = 'b and type Node.label = 'a) ->
    ?nodes:'a list -> ?edges:('a * 'a * 'b) list -> unit -> 'c
  val union :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    'c -> 'c -> 'c
  val inter :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    'c -> 'c -> 'c
  val to_dot :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?graph_attrs:('c -> Graphlib.Std.graph_attr list) ->
    ?node_attrs:('n -> Graphlib.Std.node_attr list) ->
    ?edge_attrs:('e -> Graphlib.Std.edge_attr list) ->
    ?string_of_node:('n -> string) ->
    ?string_of_edge:('e -> string) ->
    ?channel:Core_kernel.Out_channel.t ->
    ?formatter:Format.formatter -> ?filename:string -> 'c -> unit
  val depth_first_search :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool ->
    ?start:'n ->
    ?start_tree:('n -> 's -> 's) ->
    ?enter_node:(int -> 'n -> 's -> 's) ->
    ?leave_node:(int -> 'n -> 's -> 's) ->
    ?enter_edge:(Graphlib.Std.edge_kind -> 'e -> 's -> 's) ->
    ?leave_edge:(Graphlib.Std.edge_kind -> 'e -> 's -> 's) ->
    'c -> init:'s -> 's
  val depth_first_visit :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool ->
    ?start:'n -> 'c -> init:'s -> ('n, 'e, 's) Graphlib.Std.dfs_visitor -> 's
  class ['n, 'e, 's] dfs_identity_visitor : ['n, 'e, 's] dfs_visitor
  val reverse_postorder_traverse :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> ?start:'n -> 'c -> 'n Regular.Std.seq
  val postorder_traverse :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> ?start:'n -> 'c -> 'n Regular.Std.seq
  val dominators :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> 'c -> 'n -> 'n Graphlib.Std.tree
  val dom_frontier :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> 'c -> 'n Graphlib.Std.tree -> 'n Graphlib.Std.frontier
  val strong_components :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    'c -> 'n Graphlib.Std.partition
  val shortest_path :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?weight:('e -> int) ->
    ?rev:bool -> 'c -> 'n -> 'n -> 'e Graphlib.Std.path option
  val is_reachable :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> 'c -> 'n -> 'n -> bool
  val fold_reachable :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?rev:bool -> init:'a -> f:('a -> 'n -> 'a) -> 'c -> 'n -> 'a
  val compare :
    (module Graphlib.Std.Graph with type node = 'n and type t = 'a) ->
    (module Graphlib.Std.Graph with type node = 'n and type t = 'b) ->
    'a -> 'b -> int
  val filtered :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
    ?skip_node:('n -> bool) ->
    ?skip_edge:('e -> bool) ->
    unit ->
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c)
  val view :
    (module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c and type Edge.label = 'b and type Node.label = 'a) ->
    node:('n -> 'f) * ('f -> 'n) ->
    edge:('e -> 'd) * ('d -> 'e) ->
    node_label:('a -> 'p) * ('p -> 'a) ->
    edge_label:('b -> 'r) * ('r -> 'b) ->
    (module Graphlib.Std.Graph with type edge = 'd and type node = 'f and type t = 'c and type Edge.label = 'r and type Node.label = 'p)
  module To_ocamlgraph :
    functor (G : Graph) ->
      sig
        type t = G.t
        module V :
          sig
            type t = G.node
            val compare : t -> t -> int
            val hash : t -> int
            val equal : t -> t -> bool
            type label = G.Node.label
            val create : label -> t
            val label : t -> label
          end
        type vertex = V.t
        module E :
          sig
            type t = G.edge
            val compare : t -> t -> int
            type vertex = V.t
            val src : t -> vertex
            val dst : t -> vertex
            type label = G.Edge.label
            val create : vertex -> label -> vertex -> t
            val label : t -> label
          end
        type edge = E.t
        val is_directed : bool
        val is_empty : t -> bool
        val nb_vertex : t -> int
        val nb_edges : t -> int
        val out_degree : t -> vertex -> int
        val in_degree : t -> vertex -> int
        val mem_vertex : t -> vertex -> bool
        val mem_edge : t -> vertex -> vertex -> bool
        val mem_edge_e : t -> edge -> bool
        val find_edge : t -> vertex -> vertex -> edge
        val find_all_edges : t -> vertex -> vertex -> edge list
        val succ : t -> vertex -> vertex list
        val pred : t -> vertex -> vertex list
        val succ_e : t -> vertex -> edge list
        val pred_e : t -> vertex -> edge list
        val iter_vertex : (vertex -> unit) -> t -> unit
        val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
        val iter_edges : (vertex -> vertex -> unit) -> t -> unit
        val fold_edges : (vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
        val iter_edges_e : (edge -> unit) -> t -> unit
        val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
        val map_vertex : (vertex -> vertex) -> t -> t
        val iter_succ : (vertex -> unit) -> t -> vertex -> unit
        val iter_pred : (vertex -> unit) -> t -> vertex -> unit
        val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
        val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
        val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
        val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
        val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
        val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
        val empty : t
        val add_vertex : t -> vertex -> t
        val remove_vertex : t -> vertex -> t
        val add_edge : t -> vertex -> vertex -> t
        val add_edge_e : t -> edge -> t
        val remove_edge : t -> vertex -> vertex -> t
        val remove_edge_e : t -> edge -> t
      end
  module Of_ocamlgraph :
    functor (G : Graph.Sig.P) ->
      sig
        type t = G.t
        type node = G.V.t
        type edge = G.E.t
        module Node :
          sig
            type t = node
            type graph = G.t
            type label = G.V.label
            type edge = G.E.t
            val create : label -> t
            val label : t -> label
            val mem : t -> graph -> bool
            val succs : t -> graph -> t Regular.Std.seq
            val preds : t -> graph -> t Regular.Std.seq
            val inputs : t -> graph -> edge Regular.Std.seq
            val outputs : t -> graph -> edge Regular.Std.seq
            val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val has_edge : t -> t -> graph -> bool
            val edge : t -> t -> graph -> edge option
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (node, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : node -> 'a -> 'a t
                    val of_alist :
                      (node * 'a) list ->
                      [ `Duplicate_key of node | `Ok of 'a t ]
                    val of_alist_or_error :
                      (node * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (node * 'a) list -> 'a t
                    val of_alist_multi : (node * 'a) list -> 'a list t
                    val of_alist_fold :
                      (node * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (node * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node * 'a) -> 'a t
                    val of_increasing_sequence :
                      (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of node | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:node ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:node -> data:'a -> 'a t
                    val set : 'a t -> key:node -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:node -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> node -> 'a list t
                    val find_multi : 'a list t -> node -> 'a list
                    val change :
                      'a t -> node -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> node -> 'a option
                    val find_exn : 'a t -> node -> 'a
                    val remove : 'a t -> node -> 'a t
                    val mem : 'a t -> node -> bool
                    val iter_keys : 'a t -> f:(node -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:node -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> node list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (node * 'a) list
                    val validate :
                      name:(node -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (node * 'a) option
                    val min_elt_exn : 'a t -> node * 'a
                    val max_elt : 'a t -> (node * 'a) option
                    val max_elt_exn : 'a t -> node * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:node -> data:'a -> bool) -> int
                    val split :
                      'a t -> node -> 'a t * (node * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:node Base__.Maybe_bound.t ->
                      upper_bound:node Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:node ->
                      max:node ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:node -> max:node -> (node * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> node -> (node * 'a) option
                    val nth : 'a t -> int -> (node * 'a) option
                    val nth_exn : 'a t -> int -> node * 'a
                    val rank : 'a t -> node -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:node ->
                      ?keys_less_or_equal_to:node ->
                      'a t -> (node * 'a) Base__.Sequence.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (node, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : node -> 'a -> 'a t
                val of_alist :
                  (node * 'a) list ->
                  [ `Duplicate_key of node | `Ok of 'a t ]
                val of_alist_or_error :
                  (node * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (node * 'a) list -> 'a t
                val of_alist_multi : (node * 'a) list -> 'a list t
                val of_alist_fold :
                  (node * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (node * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node * 'a) -> 'a t
                val of_increasing_sequence :
                  (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of node | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn :
                  (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:node -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:node -> data:'a -> 'a t
                val set : 'a t -> key:node -> data:'a -> 'a t
                val add_multi : 'a list t -> key:node -> data:'a -> 'a list t
                val remove_multi : 'a list t -> node -> 'a list t
                val find_multi : 'a list t -> node -> 'a list
                val change :
                  'a t -> node -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> node -> 'a option
                val find_exn : 'a t -> node -> 'a
                val remove : 'a t -> node -> 'a t
                val mem : 'a t -> node -> bool
                val iter_keys : 'a t -> f:(node -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:node -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> node list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (node * 'a) list
                val validate :
                  name:(node -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (node * 'a) option
                val min_elt_exn : 'a t -> node * 'a
                val max_elt : 'a t -> (node * 'a) option
                val max_elt_exn : 'a t -> node * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:node -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:node -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:node -> data:'a -> bool) -> int
                val split : 'a t -> node -> 'a t * (node * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:node Base__.Maybe_bound.t ->
                  upper_bound:node Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:node ->
                  max:node ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:node -> max:node -> (node * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> node -> (node * 'a) option
                val nth : 'a t -> int -> (node * 'a) option
                val nth_exn : 'a t -> int -> node * 'a
                val rank : 'a t -> node -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:node ->
                  ?keys_less_or_equal_to:node ->
                  'a t -> (node * 'a) Base__.Sequence.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(node -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(node -> bool) -> bool
                    val for_all : t -> f:(node -> bool) -> bool
                    val count : t -> f:(node -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(node -> 'sum) -> 'sum
                    val find : t -> f:(node -> bool) -> node option
                    val find_map : t -> f:(node -> 'a option) -> 'a option
                    val to_list : t -> node list
                    val to_array : t -> node array
                    val invariants : t -> bool
                    val mem : t -> node -> bool
                    val add : t -> node -> t
                    val remove : t -> node -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (node, node) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         node ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of node * node
                         | `Left of node
                         | `Right of node ] -> unit) ->
                      unit
                    val filter : t -> f:(node -> bool) -> t
                    val partition_tf : t -> f:(node -> bool) -> t * t
                    val elements : t -> node list
                    val min_elt : t -> node option
                    val min_elt_exn : t -> node
                    val max_elt : t -> node option
                    val max_elt_exn : t -> node
                    val choose : t -> node option
                    val choose_exn : t -> node
                    val split : t -> node -> t * node option * t
                    val group_by :
                      t -> equiv:(node -> node -> bool) -> t list
                    val find_exn : t -> f:(node -> bool) -> node
                    val find_index : t -> int -> node option
                    val nth : t -> int -> node option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node ->
                      t ->
                      t ->
                      (node, node)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(node -> 'data) ->
                      (node, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : node -> t
                    val union_list : t list -> t
                    val of_list : node list -> t
                    val of_array : node array -> t
                    val of_sorted_array : node array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : node array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node) -> t
                    val stable_dedup_list : node list -> node list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node option) -> t
                    val of_tree : t -> t
                    val of_hash_set : node Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (node, 'a) Core_kernel__.Hashtbl.t -> t
                    val of_map_keys :
                      (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (node, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (node, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(node -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(node -> bool) -> bool
                val for_all : t -> f:(node -> bool) -> bool
                val count : t -> f:(node -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(node -> 'sum) -> 'sum
                val find : t -> f:(node -> bool) -> node option
                val find_map : t -> f:(node -> 'a option) -> 'a option
                val to_list : t -> node list
                val to_array : t -> node array
                val invariants : t -> bool
                val mem : t -> node -> bool
                val add : t -> node -> t
                val remove : t -> node -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     node -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of node * node | `Left of node | `Right of node ] ->
                     unit) ->
                  unit
                val filter : t -> f:(node -> bool) -> t
                val partition_tf : t -> f:(node -> bool) -> t * t
                val elements : t -> node list
                val min_elt : t -> node option
                val min_elt_exn : t -> node
                val max_elt : t -> node option
                val max_elt_exn : t -> node
                val choose : t -> node option
                val choose_exn : t -> node
                val split : t -> node -> t * node option * t
                val group_by : t -> equiv:(node -> node -> bool) -> t list
                val find_exn : t -> f:(node -> bool) -> node
                val find_index : t -> int -> node option
                val nth : t -> int -> node option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node ->
                  t ->
                  t ->
                  (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(node -> 'data) ->
                  (node, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : node -> t
                val union_list : t list -> t
                val of_list : node list -> t
                val of_array : node array -> t
                val of_sorted_array : node array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : node array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node) -> t
                val stable_dedup_list : node list -> node list
                val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> node option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : node Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (node, 'a) Core_kernel__.Hashtbl.t -> t
                val of_map_keys :
                  (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = node
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> node -> Core_kernel__.Import.bool
                val lookup : 'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> node -> 'a
                val enqueue :
                  'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val keys : 'a t -> node Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> node * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                val replace : 'a t -> node -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
              end
          end
        module Edge :
          sig
            type t = edge
            type node = Node.t
            type graph = Node.graph
            type label = G.E.label
            val create : node -> node -> label -> t
            val label : t -> label
            val src : t -> node
            val dst : t -> node
            val mem : t -> graph -> bool
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : edge -> 'a -> 'a t
                    val of_alist :
                      (edge * 'a) list ->
                      [ `Duplicate_key of edge | `Ok of 'a t ]
                    val of_alist_or_error :
                      (edge * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (edge * 'a) list -> 'a t
                    val of_alist_multi : (edge * 'a) list -> 'a list t
                    val of_alist_fold :
                      (edge * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (edge * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge * 'a) -> 'a t
                    val of_increasing_sequence :
                      (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of edge | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (edge, 'a) Node.Table.hashtbl -> 'a t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:edge ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                    val set : 'a t -> key:edge -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:edge -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> edge -> 'a list t
                    val find_multi : 'a list t -> edge -> 'a list
                    val change :
                      'a t -> edge -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> edge -> 'a option
                    val find_exn : 'a t -> edge -> 'a
                    val remove : 'a t -> edge -> 'a t
                    val mem : 'a t -> edge -> bool
                    val iter_keys : 'a t -> f:(edge -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:edge -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> edge list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (edge * 'a) list
                    val validate :
                      name:(edge -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (edge * 'a) option
                    val min_elt_exn : 'a t -> edge * 'a
                    val max_elt : 'a t -> (edge * 'a) option
                    val max_elt_exn : 'a t -> edge * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:edge -> data:'a -> bool) -> int
                    val split :
                      'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:edge Base__.Maybe_bound.t ->
                      upper_bound:edge Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:edge ->
                      max:edge ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:edge -> max:edge -> (edge * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> edge -> (edge * 'a) option
                    val nth : 'a t -> int -> (edge * 'a) option
                    val nth_exn : 'a t -> int -> edge * 'a
                    val rank : 'a t -> edge -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:edge ->
                      ?keys_less_or_equal_to:edge ->
                      'a t -> (edge * 'a) Base__.Sequence.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : edge -> 'a -> 'a t
                val of_alist :
                  (edge * 'a) list ->
                  [ `Duplicate_key of edge | `Ok of 'a t ]
                val of_alist_or_error :
                  (edge * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (edge * 'a) list -> 'a t
                val of_alist_multi : (edge * 'a) list -> 'a list t
                val of_alist_fold :
                  (edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (edge * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge * 'a) -> 'a t
                val of_increasing_sequence :
                  (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of edge | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:edge -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                val set : 'a t -> key:edge -> data:'a -> 'a t
                val add_multi : 'a list t -> key:edge -> data:'a -> 'a list t
                val remove_multi : 'a list t -> edge -> 'a list t
                val find_multi : 'a list t -> edge -> 'a list
                val change :
                  'a t -> edge -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> edge -> 'a option
                val find_exn : 'a t -> edge -> 'a
                val remove : 'a t -> edge -> 'a t
                val mem : 'a t -> edge -> bool
                val iter_keys : 'a t -> f:(edge -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> edge list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (edge * 'a) list
                val validate :
                  name:(edge -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (edge * 'a) option
                val min_elt_exn : 'a t -> edge * 'a
                val max_elt : 'a t -> (edge * 'a) option
                val max_elt_exn : 'a t -> edge * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
                val split : 'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:edge Base__.Maybe_bound.t ->
                  upper_bound:edge Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:edge ->
                  max:edge ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:edge -> max:edge -> (edge * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> edge -> (edge * 'a) option
                val nth : 'a t -> int -> (edge * 'a) option
                val nth_exn : 'a t -> int -> edge * 'a
                val rank : 'a t -> edge -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:edge ->
                  ?keys_less_or_equal_to:edge ->
                  'a t -> (edge * 'a) Base__.Sequence.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(edge -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(edge -> bool) -> bool
                    val for_all : t -> f:(edge -> bool) -> bool
                    val count : t -> f:(edge -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(edge -> 'sum) -> 'sum
                    val find : t -> f:(edge -> bool) -> edge option
                    val find_map : t -> f:(edge -> 'a option) -> 'a option
                    val to_list : t -> edge list
                    val to_array : t -> edge array
                    val invariants : t -> bool
                    val mem : t -> edge -> bool
                    val add : t -> edge -> t
                    val remove : t -> edge -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         edge ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of edge * edge
                         | `Left of edge
                         | `Right of edge ] -> unit) ->
                      unit
                    val filter : t -> f:(edge -> bool) -> t
                    val partition_tf : t -> f:(edge -> bool) -> t * t
                    val elements : t -> edge list
                    val min_elt : t -> edge option
                    val min_elt_exn : t -> edge
                    val max_elt : t -> edge option
                    val max_elt_exn : t -> edge
                    val choose : t -> edge option
                    val choose_exn : t -> edge
                    val split : t -> edge -> t * edge option * t
                    val group_by :
                      t -> equiv:(edge -> edge -> bool) -> t list
                    val find_exn : t -> f:(edge -> bool) -> edge
                    val find_index : t -> int -> edge option
                    val nth : t -> int -> edge option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge ->
                      t ->
                      t ->
                      (edge, edge)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(edge -> 'data) ->
                      (edge, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : edge -> t
                    val union_list : t list -> t
                    val of_list : edge list -> t
                    val of_array : edge array -> t
                    val of_sorted_array : edge array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : edge array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge) -> t
                    val stable_dedup_list : edge list -> edge list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge option) -> t
                    val of_tree : t -> t
                    val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                    val of_map_keys :
                      (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (edge, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (edge, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(edge -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(edge -> bool) -> bool
                val for_all : t -> f:(edge -> bool) -> bool
                val count : t -> f:(edge -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(edge -> 'sum) -> 'sum
                val find : t -> f:(edge -> bool) -> edge option
                val find_map : t -> f:(edge -> 'a option) -> 'a option
                val to_list : t -> edge list
                val to_array : t -> edge array
                val invariants : t -> bool
                val mem : t -> edge -> bool
                val add : t -> edge -> t
                val remove : t -> edge -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     edge -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of edge * edge | `Left of edge | `Right of edge ] ->
                     unit) ->
                  unit
                val filter : t -> f:(edge -> bool) -> t
                val partition_tf : t -> f:(edge -> bool) -> t * t
                val elements : t -> edge list
                val min_elt : t -> edge option
                val min_elt_exn : t -> edge
                val max_elt : t -> edge option
                val max_elt_exn : t -> edge
                val choose : t -> edge option
                val choose_exn : t -> edge
                val split : t -> edge -> t * edge option * t
                val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                val find_exn : t -> f:(edge -> bool) -> edge
                val find_index : t -> int -> edge option
                val nth : t -> int -> edge option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge ->
                  t ->
                  t ->
                  (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(edge -> 'data) ->
                  (edge, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : edge -> t
                val union_list : t list -> t
                val of_list : edge list -> t
                val of_array : edge array -> t
                val of_sorted_array : edge array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : edge array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge) -> t
                val stable_dedup_list : edge list -> edge list
                val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                val of_map_keys :
                  (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = edge
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> edge -> Core_kernel__.Import.bool
                val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> edge -> 'a
                val enqueue :
                  'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val keys : 'a t -> edge Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> edge * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
              end
          end
        val empty : t
        val nodes : t -> node Regular.Std.seq
        val edges : t -> edge Regular.Std.seq
        val is_directed : bool
        val number_of_edges : t -> int
        val number_of_nodes : t -> int
        val ( >= ) : t -> t -> bool
        val ( <= ) : t -> t -> bool
        val ( = ) : t -> t -> bool
        val ( > ) : t -> t -> bool
        val ( < ) : t -> t -> bool
        val ( <> ) : t -> t -> bool
        val equal : t -> t -> bool
        val min : t -> t -> t
        val max : t -> t -> t
        val ascending : t -> t -> int
        val descending : t -> t -> int
        val between : t -> low:t -> high:t -> bool
        val clamp_exn : t -> min:t -> max:t -> t
        val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
        type comparator_witness
        val comparator : (t, comparator_witness) Base__.Comparator.comparator
        val validate_lbound :
          min:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_ubound :
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_bound :
          min:t Base__.Maybe_bound.t ->
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        module Replace_polymorphic_compare :
          sig
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val min : t -> t -> t
            val max : t -> t -> t
          end
        module Map :
          sig
            module Key :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type 'a t =
                    (Key.t, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Key.t * 'a) -> 'a t
                val of_increasing_sequence :
                  (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of Key.t | `Ok of 'v t ]
                val of_tree : 'a t -> 'a t
                val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                val gen :
                  Key.t Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
                val set : 'a t -> key:Key.t -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> 'a list t
                val remove_multi : 'a list t -> Key.t -> 'a list t
                val find_multi : 'a list t -> Key.t -> 'a list
                val change :
                  'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:Key.t Base__.Maybe_bound.t ->
                  upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val nth_exn : 'a t -> int -> Key.t * 'a
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Base__.Sequence.t
                val obs :
                  Key.t Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (K : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type 'a t =
                (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
            val compare :
              ('a -> 'a -> Core_kernel__.Import.int) ->
              'a t -> 'a t -> Core_kernel__.Import.int
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_or_error :
              (Key.t * 'a) list -> 'a t Base__.Or_error.t
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_alist_reduce :
              (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
            val of_sorted_array :
              (Key.t * 'a) array -> 'a t Base__.Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Key.t * 'a) -> 'a t
            val of_increasing_sequence :
              (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
            val of_iteri :
              iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
              [ `Duplicate_key of Key.t | `Ok of 'v t ]
            val of_tree : 'a Tree.t -> 'a t
            val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
            val gen :
              Key.t Core_kernel__.Quickcheck.Generator.t ->
              'a Core_kernel__.Quickcheck.Generator.t ->
              'a t Core_kernel__.Quickcheck.Generator.t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add :
              'a t ->
              key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
            val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
            val set : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val remove_multi : 'a list t -> Key.t -> 'a list t
            val find_multi : 'a list t -> Key.t -> 'a list
            val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
            val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
            val iter : 'a t -> f:('a -> unit) -> unit
            val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold2 :
              'a t ->
              'b t ->
              init:'c ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c -> 'c) ->
              'c
            val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
            val filter : 'a t -> f:('a -> bool) -> 'a t
            val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val partition_mapi :
              'a t ->
              f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
              'b t * 'c t
            val partition_map :
              'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
            val partitioni_tf :
              'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
            val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist :
              ?key_order:[ `Decreasing | `Increasing ] ->
              'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Base__.Validate.check -> 'a t Base__.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
              Base__.Sequence.t
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
            val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
            val append :
              lower_part:'a t ->
              upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
            val subrange :
              'a t ->
              lower_bound:Key.t Base__.Maybe_bound.t ->
              upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val closest_key :
              'a t ->
              [ `Greater_or_equal_to
              | `Greater_than
              | `Less_or_equal_to
              | `Less_than ] -> Key.t -> (Key.t * 'a) option
            val nth : 'a t -> int -> (Key.t * 'a) option
            val nth_exn : 'a t -> int -> Key.t * 'a
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val to_sequence :
              ?order:[ `Decreasing_key | `Increasing_key ] ->
              ?keys_greater_or_equal_to:Key.t ->
              ?keys_less_or_equal_to:Key.t ->
              'a t -> (Key.t * 'a) Base__.Sequence.t
            val obs :
              Key.t Core_kernel__.Quickcheck.Observer.t ->
              'v Core_kernel__.Quickcheck.Observer.t ->
              'v t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Key.t Core_kernel__.Quickcheck.Shrinker.t ->
              'v Core_kernel__.Quickcheck.Shrinker.t ->
              'v t Core_kernel__.Quickcheck.Shrinker.t
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : Key.t Bin_prot.Type_class.t
                         val bin_read_t : Key.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Key.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Key.t Bin_prot.Type_class.reader
                         val bin_size_t : Key.t Bin_prot.Size.sizer
                         val bin_write_t : Key.t Bin_prot.Write.writer
                         val bin_writer_t : Key.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
            module Provide_hash :
              functor
                (Key : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Key.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    (Ppx_hash_lib.Std.Hash.state ->
                     'a -> Ppx_hash_lib.Std.Hash.state) ->
                    Ppx_hash_lib.Std.Hash.state ->
                    'a t -> Ppx_hash_lib.Std.Hash.state
                end
            val t_of_sexp :
              (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        module Set :
          sig
            module Elt :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = Map.Key.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type t =
                    (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (Elt.t, comparator_witness)
                    Core_kernel__.Set_intf.Tree.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val nth : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t ->
                  t ->
                  (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  Elt.t Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Elt.t) -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t option) -> t
                val of_tree : t -> t
                val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                val of_map_keys :
                  (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  Elt.t Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type t = (Elt.t, comparator_witness) Base.Set.t
            val compare : t -> t -> Core_kernel__.Import.int
            type named =
                (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
            val length : t -> int
            val is_empty : t -> bool
            val iter : t -> f:(Elt.t -> unit) -> unit
            val fold :
              t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
            val fold_result :
              t ->
              init:'accum ->
              f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val exists : t -> f:(Elt.t -> bool) -> bool
            val for_all : t -> f:(Elt.t -> bool) -> bool
            val count : t -> f:(Elt.t -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              t -> f:(Elt.t -> 'sum) -> 'sum
            val find : t -> f:(Elt.t -> bool) -> Elt.t option
            val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
            val to_list : t -> Elt.t list
            val to_array : t -> Elt.t array
            val invariants : t -> bool
            val mem : t -> Elt.t -> bool
            val add : t -> Elt.t -> t
            val remove : t -> Elt.t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val symmetric_diff :
              t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
            val compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val is_subset : t -> of_:t -> bool
            val subset : t -> t -> bool
            module Named :
              sig
                val is_subset : named -> of_:named -> unit Base__.Or_error.t
                val equal : named -> named -> unit Base__.Or_error.t
              end
            val fold_until :
              t ->
              init:'b ->
              f:('b ->
                 Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
              finish:('b -> 'final) -> 'final
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
            val iter2 :
              t ->
              t ->
              f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
                 unit) ->
              unit
            val filter : t -> f:(Elt.t -> bool) -> t
            val partition_tf : t -> f:(Elt.t -> bool) -> t * t
            val elements : t -> Elt.t list
            val min_elt : t -> Elt.t option
            val min_elt_exn : t -> Elt.t
            val max_elt : t -> Elt.t option
            val max_elt_exn : t -> Elt.t
            val choose : t -> Elt.t option
            val choose_exn : t -> Elt.t
            val split : t -> Elt.t -> t * Elt.t option * t
            val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
            val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
            val find_index : t -> int -> Elt.t option
            val nth : t -> int -> Elt.t option
            val remove_index : t -> int -> t
            val to_tree : t -> Tree.t
            val to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
            val merge_to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t ->
              t ->
              t ->
              (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
              Base__.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
            val obs :
              Elt.t Core_kernel__.Quickcheck.Observer.t ->
              t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
              t Core_kernel__.Quickcheck.Shrinker.t
            val empty : t
            val singleton : Elt.t -> t
            val union_list : t list -> t
            val of_list : Elt.t list -> t
            val of_array : Elt.t array -> t
            val of_sorted_array : Elt.t array -> t Base__.Or_error.t
            val of_sorted_array_unchecked : Elt.t array -> t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Elt.t) -> t
            val stable_dedup_list : Elt.t list -> Elt.t list
            val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
            val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
            val of_map_keys :
              (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
            val gen :
              Elt.t Core_kernel__.Quickcheck.Generator.t ->
              t Core_kernel__.Quickcheck.Generator.t
            module Provide_of_sexp :
              functor
                (Elt : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                       end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (Elt : sig
                         val bin_t : Elt.t Bin_prot.Type_class.t
                         val bin_read_t : Elt.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Elt.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                         val bin_size_t : Elt.t Bin_prot.Size.sizer
                         val bin_write_t : Elt.t Bin_prot.Write.writer
                         val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
            module Provide_hash :
              functor
                (Elt : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Elt.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                end
            val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
            val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        val compare : t -> t -> Core_kernel__.Import.int
        val hash_fold_t :
          Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
        val hashable : t Core_kernel__.Hashtbl.Hashable.t
        module Table :
          sig
            type key = t
            type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
            type 'b t = (key, 'b) hashtbl
            val sexp_of_t :
              ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
              'b t -> Ppx_sexp_conv_lib.Sexp.t
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
            val invariant :
              'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
            val create :
              (key, 'b, unit -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist :
              (key, 'b,
               (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              (key, 'b,
               (key * 'b) list ->
               [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_or_error :
              (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              (key, 'b, (key * 'b) list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              (key, 'b list, (key * 'b) list -> 'b list t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_mapped :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key :
              (key, 'r,
               get_key:('r -> key) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_or_error :
              (key, 'r,
               get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val group :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val sexp_of_key : 'a t -> key -> Base__.Sexp.t
            val clear : 'a t -> unit
            val copy : 'b t -> 'b t
            val fold :
              'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
            val iter_keys : 'a t -> f:(key -> unit) -> unit
            val iter : 'b t -> f:('b -> unit) -> unit
            val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
            val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val exists : 'b t -> f:('b -> bool) -> bool
            val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val for_all : 'b t -> f:('b -> bool) -> bool
            val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
            val count : 'b t -> f:('b -> bool) -> int
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val mem : 'a t -> key -> bool
            val remove : 'a t -> key -> unit
            val set : 'b t -> key:key -> data:'b -> unit
            val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : 'b t -> key:key -> data:'b -> unit
            val change : 'b t -> key -> f:('b option -> 'b option) -> unit
            val update : 'b t -> key -> f:('b option -> 'b) -> unit
            val map : 'b t -> f:('b -> 'c) -> 'c t
            val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
            val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
            val filter_mapi :
              'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
            val filter_keys : 'b t -> f:(key -> bool) -> 'b t
            val filter : 'b t -> f:('b -> bool) -> 'b t
            val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
            val partition_map :
              'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
            val partition_mapi :
              'b t ->
              f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              'c t * 'd t
            val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
            val partitioni_tf :
              'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
            val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
            val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
            val find : 'b t -> key -> 'b option
            val find_exn : 'b t -> key -> 'b
            val find_and_call :
              'b t ->
              key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
            val findi_and_call :
              'b t ->
              key ->
              if_found:(key:key -> data:'b -> 'c) ->
              if_not_found:(key -> 'c) -> 'c
            val find_and_remove : 'b t -> key -> 'b option
            val merge :
              'a t ->
              'b t ->
              f:(key:key ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            type 'a merge_into_action = Remove | Set_to of 'a
            val merge_into :
              src:'a t ->
              dst:'b t ->
              f:(key:key -> 'a -> 'b option -> 'b merge_into_action) -> unit
            val keys : 'a t -> key list
            val data : 'b t -> 'b list
            val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
            val filter_inplace : 'b t -> f:('b -> bool) -> unit
            val filteri_inplace :
              'b t -> f:(key:key -> data:'b -> bool) -> unit
            val map_inplace : 'b t -> f:('b -> 'b) -> unit
            val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
            val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
            val filter_mapi_inplace :
              'b t -> f:(key:key -> data:'b -> 'b option) -> unit
            val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
            val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
            val to_alist : 'b t -> (key * 'b) list
            val validate :
              name:(key -> string) ->
              'b Base__.Validate.check -> 'b t Base__.Validate.check
            val incr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val decr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val add_multi : 'b list t -> key:key -> data:'b -> unit
            val remove_multi : 'a list t -> key -> unit
            val find_multi : 'b list t -> key -> 'b list
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : key Bin_prot.Type_class.t
                         val bin_read_t : key Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> key)
                           Bin_prot.Read.reader
                         val bin_reader_t : key Bin_prot.Type_class.reader
                         val bin_size_t : key Bin_prot.Size.sizer
                         val bin_write_t : key Bin_prot.Write.writer
                         val bin_writer_t : key Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_t :
                    'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                  val bin_read_t :
                    'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'a Bin_prot.Read.reader ->
                    (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                  val bin_reader_t :
                    'a Bin_prot.Type_class.reader ->
                    'a t Bin_prot.Type_class.reader
                  val bin_size_t :
                    'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                  val bin_write_t :
                    'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                  val bin_writer_t :
                    'a Bin_prot.Type_class.writer ->
                    'a t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                end
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          end
        module Hash_set :
          sig
            type elt = t
            type t = elt Core_kernel__.Hash_set.t
            val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            val of_list :
              ('a, elt list -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            module Provide_of_sexp :
              functor
                (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (X : sig
                       val bin_t : elt Bin_prot.Type_class.t
                       val bin_read_t : elt Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> elt)
                         Bin_prot.Read.reader
                       val bin_reader_t : elt Bin_prot.Type_class.reader
                       val bin_size_t : elt Bin_prot.Size.sizer
                       val bin_write_t : elt Bin_prot.Write.writer
                       val bin_writer_t : elt Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end) ->
                sig
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                end
            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          end
        module Hash_queue :
          sig
            module Key :
              sig
                type t = Hash_set.elt
                val compare : t -> t -> int
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                val hash : t -> int
              end
            type 'a t
            val sexp_of_t :
              ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('a -> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 'a ->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('a -> bool) -> bool
            val for_all : 'a t -> f:('a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('a -> 'sum) -> 'sum
            val find : 'a t -> f:('a -> bool) -> 'a option
            val find_map : 'a t -> f:('a -> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val invariant : 'a t -> Core_kernel__.Import.unit
            val create :
              ?growth_allowed:Core_kernel__.Import.bool ->
              ?size:Core_kernel__.Import.int ->
              Core_kernel__.Import.unit -> 'a t
            val clear : 'a t -> Core_kernel__.Import.unit
            val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
            val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_exn : 'a t -> Key.t -> 'a
            val enqueue :
              'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
            val enqueue_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val lookup_and_move_to_back :
              'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
            val first : 'a t -> 'a Core_kernel__.Import.option
            val first_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val keys : 'a t -> Key.t Core_kernel__.Import.list
            val dequeue : 'a t -> 'a Core_kernel__.Import.option
            val dequeue_exn : 'a t -> 'a
            val dequeue_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val dequeue_with_key_exn : 'a t -> Key.t * 'a
            val dequeue_all :
              'a t ->
              f:('a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
            val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
            val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
            val replace_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val iteri :
              'a t ->
              f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val foldi :
              'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
          end
        val to_string : t -> string
        val str : unit -> t -> string
        val pps : unit -> t -> string
        val ppo : Core_kernel.Out_channel.t -> t -> unit
        val pp_seq : Format.formatter -> t Core_kernel.Sequence.t -> unit
        val pp : Base__.Formatter.t -> t -> unit
      end
  module Filtered :
    functor
      (G : Graph) (P : sig
                         type edge = G.edge
                         type node = G.node
                         val edge : edge -> bool
                         val node : node -> bool
                       end) ->
      sig
        type t = G.t
        type node = P.node
        type edge = P.edge
        module Node :
          sig
            type t = node
            type graph = G.t
            type label = G.Node.label
            type edge = P.edge
            val create : label -> t
            val label : t -> label
            val mem : t -> graph -> bool
            val succs : t -> graph -> t Regular.Std.seq
            val preds : t -> graph -> t Regular.Std.seq
            val inputs : t -> graph -> edge Regular.Std.seq
            val outputs : t -> graph -> edge Regular.Std.seq
            val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val has_edge : t -> t -> graph -> bool
            val edge : t -> t -> graph -> edge option
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness = G.Node.comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = G.Node.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (node, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : node -> 'a -> 'a t
                    val of_alist :
                      (node * 'a) list ->
                      [ `Duplicate_key of node | `Ok of 'a t ]
                    val of_alist_or_error :
                      (node * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (node * 'a) list -> 'a t
                    val of_alist_multi : (node * 'a) list -> 'a list t
                    val of_alist_fold :
                      (node * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (node * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node * 'a) -> 'a t
                    val of_increasing_sequence :
                      (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of node | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:node ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:node -> data:'a -> 'a t
                    val set : 'a t -> key:node -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:node -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> node -> 'a list t
                    val find_multi : 'a list t -> node -> 'a list
                    val change :
                      'a t -> node -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> node -> 'a option
                    val find_exn : 'a t -> node -> 'a
                    val remove : 'a t -> node -> 'a t
                    val mem : 'a t -> node -> bool
                    val iter_keys : 'a t -> f:(node -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:node -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> node list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (node * 'a) list
                    val validate :
                      name:(node -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (node * 'a) option
                    val min_elt_exn : 'a t -> node * 'a
                    val max_elt : 'a t -> (node * 'a) option
                    val max_elt_exn : 'a t -> node * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:node -> data:'a -> bool) -> int
                    val split :
                      'a t -> node -> 'a t * (node * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:node Base__.Maybe_bound.t ->
                      upper_bound:node Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:node ->
                      max:node ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:node -> max:node -> (node * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> node -> (node * 'a) option
                    val nth : 'a t -> int -> (node * 'a) option
                    val nth_exn : 'a t -> int -> node * 'a
                    val rank : 'a t -> node -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:node ->
                      ?keys_less_or_equal_to:node ->
                      'a t -> (node * 'a) Base__.Sequence.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (node, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : node -> 'a -> 'a t
                val of_alist :
                  (node * 'a) list ->
                  [ `Duplicate_key of node | `Ok of 'a t ]
                val of_alist_or_error :
                  (node * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (node * 'a) list -> 'a t
                val of_alist_multi : (node * 'a) list -> 'a list t
                val of_alist_fold :
                  (node * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (node * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node * 'a) -> 'a t
                val of_increasing_sequence :
                  (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of node | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn :
                  (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:node -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:node -> data:'a -> 'a t
                val set : 'a t -> key:node -> data:'a -> 'a t
                val add_multi : 'a list t -> key:node -> data:'a -> 'a list t
                val remove_multi : 'a list t -> node -> 'a list t
                val find_multi : 'a list t -> node -> 'a list
                val change :
                  'a t -> node -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> node -> 'a option
                val find_exn : 'a t -> node -> 'a
                val remove : 'a t -> node -> 'a t
                val mem : 'a t -> node -> bool
                val iter_keys : 'a t -> f:(node -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:node -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> node list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (node * 'a) list
                val validate :
                  name:(node -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (node * 'a) option
                val min_elt_exn : 'a t -> node * 'a
                val max_elt : 'a t -> (node * 'a) option
                val max_elt_exn : 'a t -> node * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:node -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:node -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:node -> data:'a -> bool) -> int
                val split : 'a t -> node -> 'a t * (node * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:node Base__.Maybe_bound.t ->
                  upper_bound:node Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:node ->
                  max:node ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:node -> max:node -> (node * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> node -> (node * 'a) option
                val nth : 'a t -> int -> (node * 'a) option
                val nth_exn : 'a t -> int -> node * 'a
                val rank : 'a t -> node -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:node ->
                  ?keys_less_or_equal_to:node ->
                  'a t -> (node * 'a) Base__.Sequence.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(node -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(node -> bool) -> bool
                    val for_all : t -> f:(node -> bool) -> bool
                    val count : t -> f:(node -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(node -> 'sum) -> 'sum
                    val find : t -> f:(node -> bool) -> node option
                    val find_map : t -> f:(node -> 'a option) -> 'a option
                    val to_list : t -> node list
                    val to_array : t -> node array
                    val invariants : t -> bool
                    val mem : t -> node -> bool
                    val add : t -> node -> t
                    val remove : t -> node -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (node, node) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         node ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of node * node
                         | `Left of node
                         | `Right of node ] -> unit) ->
                      unit
                    val filter : t -> f:(node -> bool) -> t
                    val partition_tf : t -> f:(node -> bool) -> t * t
                    val elements : t -> node list
                    val min_elt : t -> node option
                    val min_elt_exn : t -> node
                    val max_elt : t -> node option
                    val max_elt_exn : t -> node
                    val choose : t -> node option
                    val choose_exn : t -> node
                    val split : t -> node -> t * node option * t
                    val group_by :
                      t -> equiv:(node -> node -> bool) -> t list
                    val find_exn : t -> f:(node -> bool) -> node
                    val find_index : t -> int -> node option
                    val nth : t -> int -> node option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node ->
                      t ->
                      t ->
                      (node, node)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(node -> 'data) ->
                      (node, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : node -> t
                    val union_list : t list -> t
                    val of_list : node list -> t
                    val of_array : node array -> t
                    val of_sorted_array : node array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : node array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node) -> t
                    val stable_dedup_list : node list -> node list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node option) -> t
                    val of_tree : t -> t
                    val of_hash_set : node Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (node, 'a) Core_kernel__.Hashtbl.t -> t
                    val of_map_keys :
                      (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (node, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (node, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(node -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(node -> bool) -> bool
                val for_all : t -> f:(node -> bool) -> bool
                val count : t -> f:(node -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(node -> 'sum) -> 'sum
                val find : t -> f:(node -> bool) -> node option
                val find_map : t -> f:(node -> 'a option) -> 'a option
                val to_list : t -> node list
                val to_array : t -> node array
                val invariants : t -> bool
                val mem : t -> node -> bool
                val add : t -> node -> t
                val remove : t -> node -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     node -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of node * node | `Left of node | `Right of node ] ->
                     unit) ->
                  unit
                val filter : t -> f:(node -> bool) -> t
                val partition_tf : t -> f:(node -> bool) -> t * t
                val elements : t -> node list
                val min_elt : t -> node option
                val min_elt_exn : t -> node
                val max_elt : t -> node option
                val max_elt_exn : t -> node
                val choose : t -> node option
                val choose_exn : t -> node
                val split : t -> node -> t * node option * t
                val group_by : t -> equiv:(node -> node -> bool) -> t list
                val find_exn : t -> f:(node -> bool) -> node
                val find_index : t -> int -> node option
                val nth : t -> int -> node option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node ->
                  t ->
                  t ->
                  (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(node -> 'data) ->
                  (node, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : node -> t
                val union_list : t list -> t
                val of_list : node list -> t
                val of_array : node array -> t
                val of_sorted_array : node array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : node array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node) -> t
                val stable_dedup_list : node list -> node list
                val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> node option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : node Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (node, 'a) Core_kernel__.Hashtbl.t -> t
                val of_map_keys :
                  (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action =
                  'a G.Node.Table.merge_into_action =
                    Remove
                  | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = node
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t = 'a G.Node.Hash_queue.t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> node -> Core_kernel__.Import.bool
                val lookup : 'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> node -> 'a
                val enqueue :
                  'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val keys : 'a t -> node Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> node * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                val replace : 'a t -> node -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
              end
          end
        module Edge :
          sig
            type t = edge
            type node = Node.t
            type graph = Node.graph
            type label = G.Edge.label
            val create : node -> node -> label -> t
            val label : t -> label
            val src : t -> node
            val dst : t -> node
            val mem : t -> graph -> bool
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness = G.Edge.comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = G.Edge.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : edge -> 'a -> 'a t
                    val of_alist :
                      (edge * 'a) list ->
                      [ `Duplicate_key of edge | `Ok of 'a t ]
                    val of_alist_or_error :
                      (edge * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (edge * 'a) list -> 'a t
                    val of_alist_multi : (edge * 'a) list -> 'a list t
                    val of_alist_fold :
                      (edge * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (edge * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge * 'a) -> 'a t
                    val of_increasing_sequence :
                      (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of edge | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (edge, 'a) Node.Table.hashtbl -> 'a t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:edge ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                    val set : 'a t -> key:edge -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:edge -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> edge -> 'a list t
                    val find_multi : 'a list t -> edge -> 'a list
                    val change :
                      'a t -> edge -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> edge -> 'a option
                    val find_exn : 'a t -> edge -> 'a
                    val remove : 'a t -> edge -> 'a t
                    val mem : 'a t -> edge -> bool
                    val iter_keys : 'a t -> f:(edge -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:edge -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> edge list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (edge * 'a) list
                    val validate :
                      name:(edge -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (edge * 'a) option
                    val min_elt_exn : 'a t -> edge * 'a
                    val max_elt : 'a t -> (edge * 'a) option
                    val max_elt_exn : 'a t -> edge * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:edge -> data:'a -> bool) -> int
                    val split :
                      'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:edge Base__.Maybe_bound.t ->
                      upper_bound:edge Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:edge ->
                      max:edge ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:edge -> max:edge -> (edge * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> edge -> (edge * 'a) option
                    val nth : 'a t -> int -> (edge * 'a) option
                    val nth_exn : 'a t -> int -> edge * 'a
                    val rank : 'a t -> edge -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:edge ->
                      ?keys_less_or_equal_to:edge ->
                      'a t -> (edge * 'a) Base__.Sequence.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : edge -> 'a -> 'a t
                val of_alist :
                  (edge * 'a) list ->
                  [ `Duplicate_key of edge | `Ok of 'a t ]
                val of_alist_or_error :
                  (edge * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (edge * 'a) list -> 'a t
                val of_alist_multi : (edge * 'a) list -> 'a list t
                val of_alist_fold :
                  (edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (edge * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge * 'a) -> 'a t
                val of_increasing_sequence :
                  (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of edge | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:edge -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                val set : 'a t -> key:edge -> data:'a -> 'a t
                val add_multi : 'a list t -> key:edge -> data:'a -> 'a list t
                val remove_multi : 'a list t -> edge -> 'a list t
                val find_multi : 'a list t -> edge -> 'a list
                val change :
                  'a t -> edge -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> edge -> 'a option
                val find_exn : 'a t -> edge -> 'a
                val remove : 'a t -> edge -> 'a t
                val mem : 'a t -> edge -> bool
                val iter_keys : 'a t -> f:(edge -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> edge list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (edge * 'a) list
                val validate :
                  name:(edge -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (edge * 'a) option
                val min_elt_exn : 'a t -> edge * 'a
                val max_elt : 'a t -> (edge * 'a) option
                val max_elt_exn : 'a t -> edge * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
                val split : 'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:edge Base__.Maybe_bound.t ->
                  upper_bound:edge Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:edge ->
                  max:edge ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:edge -> max:edge -> (edge * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> edge -> (edge * 'a) option
                val nth : 'a t -> int -> (edge * 'a) option
                val nth_exn : 'a t -> int -> edge * 'a
                val rank : 'a t -> edge -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:edge ->
                  ?keys_less_or_equal_to:edge ->
                  'a t -> (edge * 'a) Base__.Sequence.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(edge -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(edge -> bool) -> bool
                    val for_all : t -> f:(edge -> bool) -> bool
                    val count : t -> f:(edge -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(edge -> 'sum) -> 'sum
                    val find : t -> f:(edge -> bool) -> edge option
                    val find_map : t -> f:(edge -> 'a option) -> 'a option
                    val to_list : t -> edge list
                    val to_array : t -> edge array
                    val invariants : t -> bool
                    val mem : t -> edge -> bool
                    val add : t -> edge -> t
                    val remove : t -> edge -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         edge ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of edge * edge
                         | `Left of edge
                         | `Right of edge ] -> unit) ->
                      unit
                    val filter : t -> f:(edge -> bool) -> t
                    val partition_tf : t -> f:(edge -> bool) -> t * t
                    val elements : t -> edge list
                    val min_elt : t -> edge option
                    val min_elt_exn : t -> edge
                    val max_elt : t -> edge option
                    val max_elt_exn : t -> edge
                    val choose : t -> edge option
                    val choose_exn : t -> edge
                    val split : t -> edge -> t * edge option * t
                    val group_by :
                      t -> equiv:(edge -> edge -> bool) -> t list
                    val find_exn : t -> f:(edge -> bool) -> edge
                    val find_index : t -> int -> edge option
                    val nth : t -> int -> edge option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge ->
                      t ->
                      t ->
                      (edge, edge)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(edge -> 'data) ->
                      (edge, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : edge -> t
                    val union_list : t list -> t
                    val of_list : edge list -> t
                    val of_array : edge array -> t
                    val of_sorted_array : edge array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : edge array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge) -> t
                    val stable_dedup_list : edge list -> edge list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge option) -> t
                    val of_tree : t -> t
                    val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                    val of_map_keys :
                      (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (edge, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (edge, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(edge -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(edge -> bool) -> bool
                val for_all : t -> f:(edge -> bool) -> bool
                val count : t -> f:(edge -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(edge -> 'sum) -> 'sum
                val find : t -> f:(edge -> bool) -> edge option
                val find_map : t -> f:(edge -> 'a option) -> 'a option
                val to_list : t -> edge list
                val to_array : t -> edge array
                val invariants : t -> bool
                val mem : t -> edge -> bool
                val add : t -> edge -> t
                val remove : t -> edge -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     edge -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of edge * edge | `Left of edge | `Right of edge ] ->
                     unit) ->
                  unit
                val filter : t -> f:(edge -> bool) -> t
                val partition_tf : t -> f:(edge -> bool) -> t * t
                val elements : t -> edge list
                val min_elt : t -> edge option
                val min_elt_exn : t -> edge
                val max_elt : t -> edge option
                val max_elt_exn : t -> edge
                val choose : t -> edge option
                val choose_exn : t -> edge
                val split : t -> edge -> t * edge option * t
                val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                val find_exn : t -> f:(edge -> bool) -> edge
                val find_index : t -> int -> edge option
                val nth : t -> int -> edge option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge ->
                  t ->
                  t ->
                  (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(edge -> 'data) ->
                  (edge, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : edge -> t
                val union_list : t list -> t
                val of_list : edge list -> t
                val of_array : edge array -> t
                val of_sorted_array : edge array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : edge array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge) -> t
                val stable_dedup_list : edge list -> edge list
                val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                val of_map_keys :
                  (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action =
                  'a G.Edge.Table.merge_into_action =
                    Remove
                  | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = edge
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t = 'a G.Edge.Hash_queue.t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> edge -> Core_kernel__.Import.bool
                val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> edge -> 'a
                val enqueue :
                  'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val keys : 'a t -> edge Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> edge * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
              end
          end
        val empty : t
        val nodes : t -> node Regular.Std.seq
        val edges : t -> edge Regular.Std.seq
        val is_directed : bool
        val number_of_edges : t -> int
        val number_of_nodes : t -> int
        val ( >= ) : t -> t -> bool
        val ( <= ) : t -> t -> bool
        val ( = ) : t -> t -> bool
        val ( > ) : t -> t -> bool
        val ( < ) : t -> t -> bool
        val ( <> ) : t -> t -> bool
        val equal : t -> t -> bool
        val min : t -> t -> t
        val max : t -> t -> t
        val ascending : t -> t -> int
        val descending : t -> t -> int
        val between : t -> low:t -> high:t -> bool
        val clamp_exn : t -> min:t -> max:t -> t
        val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
        type comparator_witness
        val comparator : (t, comparator_witness) Base__.Comparator.comparator
        val validate_lbound :
          min:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_ubound :
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_bound :
          min:t Base__.Maybe_bound.t ->
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        module Replace_polymorphic_compare :
          sig
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val min : t -> t -> t
            val max : t -> t -> t
          end
        module Map :
          sig
            module Key :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type 'a t =
                    (Key.t, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Key.t * 'a) -> 'a t
                val of_increasing_sequence :
                  (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of Key.t | `Ok of 'v t ]
                val of_tree : 'a t -> 'a t
                val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                val gen :
                  Key.t Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
                val set : 'a t -> key:Key.t -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> 'a list t
                val remove_multi : 'a list t -> Key.t -> 'a list t
                val find_multi : 'a list t -> Key.t -> 'a list
                val change :
                  'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:Key.t Base__.Maybe_bound.t ->
                  upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val nth_exn : 'a t -> int -> Key.t * 'a
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Base__.Sequence.t
                val obs :
                  Key.t Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (K : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type 'a t =
                (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
            val compare :
              ('a -> 'a -> Core_kernel__.Import.int) ->
              'a t -> 'a t -> Core_kernel__.Import.int
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_or_error :
              (Key.t * 'a) list -> 'a t Base__.Or_error.t
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_alist_reduce :
              (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
            val of_sorted_array :
              (Key.t * 'a) array -> 'a t Base__.Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Key.t * 'a) -> 'a t
            val of_increasing_sequence :
              (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
            val of_iteri :
              iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
              [ `Duplicate_key of Key.t | `Ok of 'v t ]
            val of_tree : 'a Tree.t -> 'a t
            val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
            val gen :
              Key.t Core_kernel__.Quickcheck.Generator.t ->
              'a Core_kernel__.Quickcheck.Generator.t ->
              'a t Core_kernel__.Quickcheck.Generator.t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add :
              'a t ->
              key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
            val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
            val set : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val remove_multi : 'a list t -> Key.t -> 'a list t
            val find_multi : 'a list t -> Key.t -> 'a list
            val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
            val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
            val iter : 'a t -> f:('a -> unit) -> unit
            val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold2 :
              'a t ->
              'b t ->
              init:'c ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c -> 'c) ->
              'c
            val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
            val filter : 'a t -> f:('a -> bool) -> 'a t
            val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val partition_mapi :
              'a t ->
              f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
              'b t * 'c t
            val partition_map :
              'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
            val partitioni_tf :
              'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
            val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist :
              ?key_order:[ `Decreasing | `Increasing ] ->
              'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Base__.Validate.check -> 'a t Base__.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
              Base__.Sequence.t
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
            val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
            val append :
              lower_part:'a t ->
              upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
            val subrange :
              'a t ->
              lower_bound:Key.t Base__.Maybe_bound.t ->
              upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val closest_key :
              'a t ->
              [ `Greater_or_equal_to
              | `Greater_than
              | `Less_or_equal_to
              | `Less_than ] -> Key.t -> (Key.t * 'a) option
            val nth : 'a t -> int -> (Key.t * 'a) option
            val nth_exn : 'a t -> int -> Key.t * 'a
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val to_sequence :
              ?order:[ `Decreasing_key | `Increasing_key ] ->
              ?keys_greater_or_equal_to:Key.t ->
              ?keys_less_or_equal_to:Key.t ->
              'a t -> (Key.t * 'a) Base__.Sequence.t
            val obs :
              Key.t Core_kernel__.Quickcheck.Observer.t ->
              'v Core_kernel__.Quickcheck.Observer.t ->
              'v t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Key.t Core_kernel__.Quickcheck.Shrinker.t ->
              'v Core_kernel__.Quickcheck.Shrinker.t ->
              'v t Core_kernel__.Quickcheck.Shrinker.t
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : Key.t Bin_prot.Type_class.t
                         val bin_read_t : Key.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Key.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Key.t Bin_prot.Type_class.reader
                         val bin_size_t : Key.t Bin_prot.Size.sizer
                         val bin_write_t : Key.t Bin_prot.Write.writer
                         val bin_writer_t : Key.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
            module Provide_hash :
              functor
                (Key : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Key.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    (Ppx_hash_lib.Std.Hash.state ->
                     'a -> Ppx_hash_lib.Std.Hash.state) ->
                    Ppx_hash_lib.Std.Hash.state ->
                    'a t -> Ppx_hash_lib.Std.Hash.state
                end
            val t_of_sexp :
              (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        module Set :
          sig
            module Elt :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = Map.Key.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type t =
                    (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (Elt.t, comparator_witness)
                    Core_kernel__.Set_intf.Tree.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val nth : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t ->
                  t ->
                  (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  Elt.t Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Elt.t) -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t option) -> t
                val of_tree : t -> t
                val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                val of_map_keys :
                  (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  Elt.t Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type t = (Elt.t, comparator_witness) Base.Set.t
            val compare : t -> t -> Core_kernel__.Import.int
            type named =
                (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
            val length : t -> int
            val is_empty : t -> bool
            val iter : t -> f:(Elt.t -> unit) -> unit
            val fold :
              t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
            val fold_result :
              t ->
              init:'accum ->
              f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val exists : t -> f:(Elt.t -> bool) -> bool
            val for_all : t -> f:(Elt.t -> bool) -> bool
            val count : t -> f:(Elt.t -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              t -> f:(Elt.t -> 'sum) -> 'sum
            val find : t -> f:(Elt.t -> bool) -> Elt.t option
            val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
            val to_list : t -> Elt.t list
            val to_array : t -> Elt.t array
            val invariants : t -> bool
            val mem : t -> Elt.t -> bool
            val add : t -> Elt.t -> t
            val remove : t -> Elt.t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val symmetric_diff :
              t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
            val compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val is_subset : t -> of_:t -> bool
            val subset : t -> t -> bool
            module Named :
              sig
                val is_subset : named -> of_:named -> unit Base__.Or_error.t
                val equal : named -> named -> unit Base__.Or_error.t
              end
            val fold_until :
              t ->
              init:'b ->
              f:('b ->
                 Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
              finish:('b -> 'final) -> 'final
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
            val iter2 :
              t ->
              t ->
              f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
                 unit) ->
              unit
            val filter : t -> f:(Elt.t -> bool) -> t
            val partition_tf : t -> f:(Elt.t -> bool) -> t * t
            val elements : t -> Elt.t list
            val min_elt : t -> Elt.t option
            val min_elt_exn : t -> Elt.t
            val max_elt : t -> Elt.t option
            val max_elt_exn : t -> Elt.t
            val choose : t -> Elt.t option
            val choose_exn : t -> Elt.t
            val split : t -> Elt.t -> t * Elt.t option * t
            val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
            val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
            val find_index : t -> int -> Elt.t option
            val nth : t -> int -> Elt.t option
            val remove_index : t -> int -> t
            val to_tree : t -> Tree.t
            val to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
            val merge_to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t ->
              t ->
              t ->
              (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
              Base__.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
            val obs :
              Elt.t Core_kernel__.Quickcheck.Observer.t ->
              t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
              t Core_kernel__.Quickcheck.Shrinker.t
            val empty : t
            val singleton : Elt.t -> t
            val union_list : t list -> t
            val of_list : Elt.t list -> t
            val of_array : Elt.t array -> t
            val of_sorted_array : Elt.t array -> t Base__.Or_error.t
            val of_sorted_array_unchecked : Elt.t array -> t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Elt.t) -> t
            val stable_dedup_list : Elt.t list -> Elt.t list
            val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
            val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
            val of_map_keys :
              (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
            val gen :
              Elt.t Core_kernel__.Quickcheck.Generator.t ->
              t Core_kernel__.Quickcheck.Generator.t
            module Provide_of_sexp :
              functor
                (Elt : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                       end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (Elt : sig
                         val bin_t : Elt.t Bin_prot.Type_class.t
                         val bin_read_t : Elt.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Elt.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                         val bin_size_t : Elt.t Bin_prot.Size.sizer
                         val bin_write_t : Elt.t Bin_prot.Write.writer
                         val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
            module Provide_hash :
              functor
                (Elt : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Elt.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                end
            val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
            val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        val compare : t -> t -> Core_kernel__.Import.int
        val hash_fold_t :
          Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
        val hashable : t Core_kernel__.Hashtbl.Hashable.t
        module Table :
          sig
            type key = t
            type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
            type 'b t = (key, 'b) hashtbl
            val sexp_of_t :
              ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
              'b t -> Ppx_sexp_conv_lib.Sexp.t
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
            val invariant :
              'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
            val create :
              (key, 'b, unit -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist :
              (key, 'b,
               (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              (key, 'b,
               (key * 'b) list ->
               [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_or_error :
              (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              (key, 'b, (key * 'b) list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              (key, 'b list, (key * 'b) list -> 'b list t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_mapped :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key :
              (key, 'r,
               get_key:('r -> key) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_or_error :
              (key, 'r,
               get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val group :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val sexp_of_key : 'a t -> key -> Base__.Sexp.t
            val clear : 'a t -> unit
            val copy : 'b t -> 'b t
            val fold :
              'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
            val iter_keys : 'a t -> f:(key -> unit) -> unit
            val iter : 'b t -> f:('b -> unit) -> unit
            val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
            val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val exists : 'b t -> f:('b -> bool) -> bool
            val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val for_all : 'b t -> f:('b -> bool) -> bool
            val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
            val count : 'b t -> f:('b -> bool) -> int
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val mem : 'a t -> key -> bool
            val remove : 'a t -> key -> unit
            val set : 'b t -> key:key -> data:'b -> unit
            val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : 'b t -> key:key -> data:'b -> unit
            val change : 'b t -> key -> f:('b option -> 'b option) -> unit
            val update : 'b t -> key -> f:('b option -> 'b) -> unit
            val map : 'b t -> f:('b -> 'c) -> 'c t
            val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
            val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
            val filter_mapi :
              'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
            val filter_keys : 'b t -> f:(key -> bool) -> 'b t
            val filter : 'b t -> f:('b -> bool) -> 'b t
            val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
            val partition_map :
              'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
            val partition_mapi :
              'b t ->
              f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              'c t * 'd t
            val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
            val partitioni_tf :
              'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
            val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
            val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
            val find : 'b t -> key -> 'b option
            val find_exn : 'b t -> key -> 'b
            val find_and_call :
              'b t ->
              key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
            val findi_and_call :
              'b t ->
              key ->
              if_found:(key:key -> data:'b -> 'c) ->
              if_not_found:(key -> 'c) -> 'c
            val find_and_remove : 'b t -> key -> 'b option
            val merge :
              'a t ->
              'b t ->
              f:(key:key ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            type 'a merge_into_action = Remove | Set_to of 'a
            val merge_into :
              src:'a t ->
              dst:'b t ->
              f:(key:key -> 'a -> 'b option -> 'b merge_into_action) -> unit
            val keys : 'a t -> key list
            val data : 'b t -> 'b list
            val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
            val filter_inplace : 'b t -> f:('b -> bool) -> unit
            val filteri_inplace :
              'b t -> f:(key:key -> data:'b -> bool) -> unit
            val map_inplace : 'b t -> f:('b -> 'b) -> unit
            val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
            val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
            val filter_mapi_inplace :
              'b t -> f:(key:key -> data:'b -> 'b option) -> unit
            val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
            val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
            val to_alist : 'b t -> (key * 'b) list
            val validate :
              name:(key -> string) ->
              'b Base__.Validate.check -> 'b t Base__.Validate.check
            val incr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val decr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val add_multi : 'b list t -> key:key -> data:'b -> unit
            val remove_multi : 'a list t -> key -> unit
            val find_multi : 'b list t -> key -> 'b list
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : key Bin_prot.Type_class.t
                         val bin_read_t : key Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> key)
                           Bin_prot.Read.reader
                         val bin_reader_t : key Bin_prot.Type_class.reader
                         val bin_size_t : key Bin_prot.Size.sizer
                         val bin_write_t : key Bin_prot.Write.writer
                         val bin_writer_t : key Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_t :
                    'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                  val bin_read_t :
                    'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'a Bin_prot.Read.reader ->
                    (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                  val bin_reader_t :
                    'a Bin_prot.Type_class.reader ->
                    'a t Bin_prot.Type_class.reader
                  val bin_size_t :
                    'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                  val bin_write_t :
                    'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                  val bin_writer_t :
                    'a Bin_prot.Type_class.writer ->
                    'a t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                end
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          end
        module Hash_set :
          sig
            type elt = t
            type t = elt Core_kernel__.Hash_set.t
            val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            val of_list :
              ('a, elt list -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            module Provide_of_sexp :
              functor
                (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (X : sig
                       val bin_t : elt Bin_prot.Type_class.t
                       val bin_read_t : elt Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> elt)
                         Bin_prot.Read.reader
                       val bin_reader_t : elt Bin_prot.Type_class.reader
                       val bin_size_t : elt Bin_prot.Size.sizer
                       val bin_write_t : elt Bin_prot.Write.writer
                       val bin_writer_t : elt Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end) ->
                sig
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                end
            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          end
        module Hash_queue :
          sig
            module Key :
              sig
                type t = Hash_set.elt
                val compare : t -> t -> int
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                val hash : t -> int
              end
            type 'a t
            val sexp_of_t :
              ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('a -> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 'a ->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('a -> bool) -> bool
            val for_all : 'a t -> f:('a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('a -> 'sum) -> 'sum
            val find : 'a t -> f:('a -> bool) -> 'a option
            val find_map : 'a t -> f:('a -> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val invariant : 'a t -> Core_kernel__.Import.unit
            val create :
              ?growth_allowed:Core_kernel__.Import.bool ->
              ?size:Core_kernel__.Import.int ->
              Core_kernel__.Import.unit -> 'a t
            val clear : 'a t -> Core_kernel__.Import.unit
            val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
            val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_exn : 'a t -> Key.t -> 'a
            val enqueue :
              'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
            val enqueue_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val lookup_and_move_to_back :
              'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
            val first : 'a t -> 'a Core_kernel__.Import.option
            val first_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val keys : 'a t -> Key.t Core_kernel__.Import.list
            val dequeue : 'a t -> 'a Core_kernel__.Import.option
            val dequeue_exn : 'a t -> 'a
            val dequeue_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val dequeue_with_key_exn : 'a t -> Key.t * 'a
            val dequeue_all :
              'a t ->
              f:('a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
            val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
            val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
            val replace_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val iteri :
              'a t ->
              f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val foldi :
              'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
          end
        val to_string : t -> string
        val str : unit -> t -> string
        val pps : unit -> t -> string
        val ppo : Core_kernel.Out_channel.t -> t -> unit
        val pp_seq : Format.formatter -> t Core_kernel.Sequence.t -> unit
        val pp : Base__.Formatter.t -> t -> unit
      end
  module Mapper :
    functor
      (G : Graph) (N : sig
                         type s = G.node
                         type t
                         val forward : s -> t
                         val backward : t -> s
                       end) (E : sig
                                   type s = G.edge
                                   type t
                                   val forward : s -> t
                                   val backward : t -> s
                                 end) (NL : sig
                                              type s = G.Node.label
                                              type t
                                              val forward : s -> t
                                              val backward : t -> s
                                            end) (EL : sig
                                                         type s =
                                                             G.Edge.label
                                                         type t
                                                         val forward : s -> t
                                                         val backward :
                                                           t -> s
                                                       end) ->
      sig
        type t = G.t
        type node = N.t
        type edge = E.t
        module Node :
          sig
            type t = node
            type graph = G.t
            type label = NL.t
            type edge = E.t
            val create : label -> t
            val label : t -> label
            val mem : t -> graph -> bool
            val succs : t -> graph -> t Regular.Std.seq
            val preds : t -> graph -> t Regular.Std.seq
            val inputs : t -> graph -> edge Regular.Std.seq
            val outputs : t -> graph -> edge Regular.Std.seq
            val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val has_edge : t -> t -> graph -> bool
            val edge : t -> t -> graph -> edge option
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (node, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : node -> 'a -> 'a t
                    val of_alist :
                      (node * 'a) list ->
                      [ `Duplicate_key of node | `Ok of 'a t ]
                    val of_alist_or_error :
                      (node * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (node * 'a) list -> 'a t
                    val of_alist_multi : (node * 'a) list -> 'a list t
                    val of_alist_fold :
                      (node * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (node * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node * 'a) -> 'a t
                    val of_increasing_sequence :
                      (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of node | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:node ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:node -> data:'a -> 'a t
                    val set : 'a t -> key:node -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:node -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> node -> 'a list t
                    val find_multi : 'a list t -> node -> 'a list
                    val change :
                      'a t -> node -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> node -> 'a option
                    val find_exn : 'a t -> node -> 'a
                    val remove : 'a t -> node -> 'a t
                    val mem : 'a t -> node -> bool
                    val iter_keys : 'a t -> f:(node -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:node -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:node ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> node list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (node * 'a) list
                    val validate :
                      name:(node -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:node ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (node * 'a) option
                    val min_elt_exn : 'a t -> node * 'a
                    val max_elt : 'a t -> (node * 'a) option
                    val max_elt_exn : 'a t -> node * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:node -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:node -> data:'a -> bool) -> int
                    val split :
                      'a t -> node -> 'a t * (node * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:node Base__.Maybe_bound.t ->
                      upper_bound:node Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:node ->
                      max:node ->
                      init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:node -> max:node -> (node * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> node -> (node * 'a) option
                    val nth : 'a t -> int -> (node * 'a) option
                    val nth_exn : 'a t -> int -> node * 'a
                    val rank : 'a t -> node -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:node ->
                      ?keys_less_or_equal_to:node ->
                      'a t -> (node * 'a) Base__.Sequence.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> node
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (node, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : node -> 'a -> 'a t
                val of_alist :
                  (node * 'a) list ->
                  [ `Duplicate_key of node | `Ok of 'a t ]
                val of_alist_or_error :
                  (node * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (node * 'a) list -> 'a t
                val of_alist_multi : (node * 'a) list -> 'a list t
                val of_alist_fold :
                  (node * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (node * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node * 'a) -> 'a t
                val of_increasing_sequence :
                  (node * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of node | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn :
                  (node, 'a) Core_kernel__.Hashtbl.t -> 'a t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:node -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:node -> data:'a -> 'a t
                val set : 'a t -> key:node -> data:'a -> 'a t
                val add_multi : 'a list t -> key:node -> data:'a -> 'a list t
                val remove_multi : 'a list t -> node -> 'a list t
                val find_multi : 'a list t -> node -> 'a list
                val change :
                  'a t -> node -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> node -> 'a option
                val find_exn : 'a t -> node -> 'a
                val remove : 'a t -> node -> 'a t
                val mem : 'a t -> node -> bool
                val iter_keys : 'a t -> f:(node -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:node -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:node ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:node -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> node list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (node * 'a) list
                val validate :
                  name:(node -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:node ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (node, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (node * 'a) option
                val min_elt_exn : 'a t -> node * 'a
                val max_elt : 'a t -> (node * 'a) option
                val max_elt_exn : 'a t -> node * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:node -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:node -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:node -> data:'a -> bool) -> int
                val split : 'a t -> node -> 'a t * (node * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:node Base__.Maybe_bound.t ->
                  upper_bound:node Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:node ->
                  max:node ->
                  init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:node -> max:node -> (node * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> node -> (node * 'a) option
                val nth : 'a t -> int -> (node * 'a) option
                val nth_exn : 'a t -> int -> node * 'a
                val rank : 'a t -> node -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:node ->
                  ?keys_less_or_equal_to:node ->
                  'a t -> (node * 'a) Base__.Sequence.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = node
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (node, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(node -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(node -> bool) -> bool
                    val for_all : t -> f:(node -> bool) -> bool
                    val count : t -> f:(node -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(node -> 'sum) -> 'sum
                    val find : t -> f:(node -> bool) -> node option
                    val find_map : t -> f:(node -> 'a option) -> 'a option
                    val to_list : t -> node list
                    val to_array : t -> node array
                    val invariants : t -> bool
                    val mem : t -> node -> bool
                    val add : t -> node -> t
                    val remove : t -> node -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (node, node) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         node ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of node * node
                         | `Left of node
                         | `Right of node ] -> unit) ->
                      unit
                    val filter : t -> f:(node -> bool) -> t
                    val partition_tf : t -> f:(node -> bool) -> t * t
                    val elements : t -> node list
                    val min_elt : t -> node option
                    val min_elt_exn : t -> node
                    val max_elt : t -> node option
                    val max_elt_exn : t -> node
                    val choose : t -> node option
                    val choose_exn : t -> node
                    val split : t -> node -> t * node option * t
                    val group_by :
                      t -> equiv:(node -> node -> bool) -> t list
                    val find_exn : t -> f:(node -> bool) -> node
                    val find_index : t -> int -> node option
                    val nth : t -> int -> node option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:node ->
                      ?less_or_equal_to:node ->
                      t ->
                      t ->
                      (node, node)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(node -> 'data) ->
                      (node, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      node Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      node Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : node -> t
                    val union_list : t list -> t
                    val of_list : node list -> t
                    val of_array : node array -> t
                    val of_sorted_array : node array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : node array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> node) -> t
                    val stable_dedup_list : node list -> node list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> node option) -> t
                    val of_tree : t -> t
                    val of_hash_set : node Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (node, 'a) Core_kernel__.Hashtbl.t -> t
                    val of_map_keys :
                      (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      node Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> node
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (node, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (node, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(node -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(node -> bool) -> bool
                val for_all : t -> f:(node -> bool) -> bool
                val count : t -> f:(node -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(node -> 'sum) -> 'sum
                val find : t -> f:(node -> bool) -> node option
                val find_map : t -> f:(node -> 'a option) -> 'a option
                val to_list : t -> node list
                val to_array : t -> node array
                val invariants : t -> bool
                val mem : t -> node -> bool
                val add : t -> node -> t
                val remove : t -> node -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     node -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of node * node | `Left of node | `Right of node ] ->
                     unit) ->
                  unit
                val filter : t -> f:(node -> bool) -> t
                val partition_tf : t -> f:(node -> bool) -> t * t
                val elements : t -> node list
                val min_elt : t -> node option
                val min_elt_exn : t -> node
                val max_elt : t -> node option
                val max_elt_exn : t -> node
                val choose : t -> node option
                val choose_exn : t -> node
                val split : t -> node -> t * node option * t
                val group_by : t -> equiv:(node -> node -> bool) -> t list
                val find_exn : t -> f:(node -> bool) -> node
                val find_index : t -> int -> node option
                val nth : t -> int -> node option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:node ->
                  ?less_or_equal_to:node ->
                  t ->
                  t ->
                  (node, node) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(node -> 'data) ->
                  (node, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  node Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  node Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : node -> t
                val union_list : t list -> t
                val of_list : node list -> t
                val of_array : node array -> t
                val of_sorted_array : node array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : node array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> node) -> t
                val stable_dedup_list : node list -> node list
                val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> node option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : node Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (node, 'a) Core_kernel__.Hashtbl.t -> t
                val of_map_keys :
                  (node, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  node Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> node
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : node Bin_prot.Type_class.t
                             val bin_read_t : node Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> node)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               node Bin_prot.Type_class.reader
                             val bin_size_t : node Bin_prot.Size.sizer
                             val bin_write_t : node Bin_prot.Write.writer
                             val bin_writer_t :
                               node Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> node -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Core_kernel__.Hashtbl.t
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = node
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> node -> Core_kernel__.Import.bool
                val lookup : 'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> node -> 'a
                val enqueue :
                  'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> node -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val keys : 'a t -> node Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (node * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> node * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                val replace : 'a t -> node -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> node -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
              end
          end
        module Edge :
          sig
            type t = edge
            type node = Node.t
            type graph = Node.graph
            type label = EL.t
            val create : node -> node -> label -> t
            val label : t -> label
            val src : t -> node
            val dst : t -> node
            val mem : t -> graph -> bool
            val insert : t -> graph -> graph
            val update : t -> label -> graph -> graph
            val remove : t -> graph -> graph
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val min : t -> t -> t
            val max : t -> t -> t
            val ascending : t -> t -> int
            val descending : t -> t -> int
            val between : t -> low:t -> high:t -> bool
            val clamp_exn : t -> min:t -> max:t -> t
            val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
            type comparator_witness
            val comparator :
              (t, comparator_witness) Base__.Comparator.comparator
            val validate_lbound :
              min:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_ubound :
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            val validate_bound :
              min:t Base__.Maybe_bound.t ->
              max:t Base__.Maybe_bound.t -> t Base__.Validate.check
            module Replace_polymorphic_compare :
              sig
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val compare : t -> t -> int
                val min : t -> t -> t
                val max : t -> t -> t
              end
            module Map :
              sig
                module Key :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type 'a t =
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Map_intf.Tree.t
                    val empty : 'a t
                    val singleton : edge -> 'a -> 'a t
                    val of_alist :
                      (edge * 'a) list ->
                      [ `Duplicate_key of edge | `Ok of 'a t ]
                    val of_alist_or_error :
                      (edge * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (edge * 'a) list -> 'a t
                    val of_alist_multi : (edge * 'a) list -> 'a list t
                    val of_alist_fold :
                      (edge * 'a) list ->
                      init:'b -> f:('b -> 'a -> 'b) -> 'b t
                    val of_alist_reduce :
                      (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                    val of_sorted_array :
                      (edge * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge * 'a) -> 'a t
                    val of_increasing_sequence :
                      (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                    val of_iteri :
                      iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                      [ `Duplicate_key of edge | `Ok of 'v t ]
                    val of_tree : 'a t -> 'a t
                    val of_hashtbl_exn :
                      (edge, 'a) Node.Table.hashtbl -> 'a t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      'a Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add :
                      'a t ->
                      key:edge ->
                      data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                    val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                    val set : 'a t -> key:edge -> data:'a -> 'a t
                    val add_multi :
                      'a list t -> key:edge -> data:'a -> 'a list t
                    val remove_multi : 'a list t -> edge -> 'a list t
                    val find_multi : 'a list t -> edge -> 'a list
                    val change :
                      'a t -> edge -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> edge -> 'a option
                    val find_exn : 'a t -> edge -> 'a
                    val remove : 'a t -> edge -> 'a t
                    val mem : 'a t -> edge -> bool
                    val iter_keys : 'a t -> f:(edge -> unit) -> unit
                    val iter : 'a t -> f:('a -> unit) -> unit
                    val iteri :
                      'a t -> f:(key:edge -> data:'a -> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('a -> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'c ->
                      f:(key:edge ->
                         data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c -> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                    val filter : 'a t -> f:('a -> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                    val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('a -> 'a -> int) -> 'a t -> 'a t -> int
                    val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> edge list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (edge * 'a) list
                    val validate :
                      name:(edge -> string) ->
                      'a Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:edge ->
                         [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('a -> 'a -> bool) ->
                      (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (edge * 'a) option
                    val min_elt_exn : 'a t -> edge * 'a
                    val max_elt : 'a t -> (edge * 'a) option
                    val max_elt_exn : 'a t -> edge * 'a
                    val for_all : 'a t -> f:('a -> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val exists : 'a t -> f:('a -> bool) -> bool
                    val existsi :
                      'a t -> f:(key:edge -> data:'a -> bool) -> bool
                    val count : 'a t -> f:('a -> bool) -> int
                    val counti :
                      'a t -> f:(key:edge -> data:'a -> bool) -> int
                    val split :
                      'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:edge Base__.Maybe_bound.t ->
                      upper_bound:edge Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:edge ->
                      max:edge ->
                      init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:edge -> max:edge -> (edge * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> edge -> (edge * 'a) option
                    val nth : 'a t -> int -> (edge * 'a) option
                    val nth_exn : 'a t -> int -> edge * 'a
                    val rank : 'a t -> edge -> int option
                    val to_tree : 'a t -> 'a t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:edge ->
                      ?keys_less_or_equal_to:edge ->
                      'a t -> (edge * 'a) Base__.Sequence.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      'v Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      'v Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (K : sig
                               val t_of_sexp :
                                 Ppx_sexp_conv_lib.Sexp.t -> edge
                             end) ->
                        sig
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                        end
                    val t_of_sexp :
                      (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                      Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                      'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type 'a t =
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Map.t
                val compare :
                  ('a -> 'a -> Core_kernel__.Import.int) ->
                  'a t -> 'a t -> Core_kernel__.Import.int
                val empty : 'a t
                val singleton : edge -> 'a -> 'a t
                val of_alist :
                  (edge * 'a) list ->
                  [ `Duplicate_key of edge | `Ok of 'a t ]
                val of_alist_or_error :
                  (edge * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (edge * 'a) list -> 'a t
                val of_alist_multi : (edge * 'a) list -> 'a list t
                val of_alist_fold :
                  (edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (edge * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge * 'a) -> 'a t
                val of_increasing_sequence :
                  (edge * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of edge | `Ok of 'v t ]
                val of_tree : 'a Tree.t -> 'a t
                val of_hashtbl_exn : (edge, 'a) Node.Table.hashtbl -> 'a t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:edge -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:edge -> data:'a -> 'a t
                val set : 'a t -> key:edge -> data:'a -> 'a t
                val add_multi : 'a list t -> key:edge -> data:'a -> 'a list t
                val remove_multi : 'a list t -> edge -> 'a list t
                val find_multi : 'a list t -> edge -> 'a list
                val change :
                  'a t -> edge -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> edge -> 'a option
                val find_exn : 'a t -> edge -> 'a
                val remove : 'a t -> edge -> 'a t
                val mem : 'a t -> edge -> bool
                val iter_keys : 'a t -> f:(edge -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:edge ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri : 'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> edge list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (edge * 'a) list
                val validate :
                  name:(edge -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:edge ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (edge, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (edge * 'a) option
                val min_elt_exn : 'a t -> edge * 'a
                val max_elt : 'a t -> (edge * 'a) option
                val max_elt_exn : 'a t -> edge * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi : 'a t -> f:(key:edge -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
                val split : 'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:edge Base__.Maybe_bound.t ->
                  upper_bound:edge Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:edge ->
                  max:edge ->
                  init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:edge -> max:edge -> (edge * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> edge -> (edge * 'a) option
                val nth : 'a t -> int -> (edge * 'a) option
                val nth_exn : 'a t -> int -> edge * 'a
                val rank : 'a t -> edge -> int option
                val to_tree : 'a t -> 'a Tree.t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:edge ->
                  ?keys_less_or_equal_to:edge ->
                  'a t -> (edge * 'a) Base__.Sequence.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                module Provide_hash :
                  functor
                    (Key : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        (Ppx_hash_lib.Std.Hash.state ->
                         'a -> Ppx_hash_lib.Std.Hash.state) ->
                        Ppx_hash_lib.Std.Hash.state ->
                        'a t -> Ppx_hash_lib.Std.Hash.state
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            module Set :
              sig
                module Elt :
                  sig
                    type t = edge
                    val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                    type comparator_witness = Map.Key.comparator_witness
                    val comparator :
                      (t, comparator_witness)
                      Core_kernel__.Comparator.comparator
                  end
                module Tree :
                  sig
                    type t =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    type named =
                        (edge, comparator_witness)
                        Core_kernel__.Set_intf.Tree.Named.t
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(edge -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(edge -> bool) -> bool
                    val for_all : t -> f:(edge -> bool) -> bool
                    val count : t -> f:(edge -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(edge -> 'sum) -> 'sum
                    val find : t -> f:(edge -> bool) -> edge option
                    val find_map : t -> f:(edge -> 'a option) -> 'a option
                    val to_list : t -> edge list
                    val to_array : t -> edge array
                    val invariants : t -> bool
                    val mem : t -> edge -> bool
                    val add : t -> edge -> t
                    val remove : t -> edge -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    module Named :
                      sig
                        val is_subset :
                          named -> of_:named -> unit Base__.Or_error.t
                        val equal : named -> named -> unit Base__.Or_error.t
                      end
                    val fold_until :
                      t ->
                      init:'b ->
                      f:('b ->
                         edge ->
                         ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                      finish:('b -> 'final) -> 'final
                    val fold_right :
                      t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of edge * edge
                         | `Left of edge
                         | `Right of edge ] -> unit) ->
                      unit
                    val filter : t -> f:(edge -> bool) -> t
                    val partition_tf : t -> f:(edge -> bool) -> t * t
                    val elements : t -> edge list
                    val min_elt : t -> edge option
                    val min_elt_exn : t -> edge
                    val max_elt : t -> edge option
                    val max_elt_exn : t -> edge
                    val choose : t -> edge option
                    val choose_exn : t -> edge
                    val split : t -> edge -> t * edge option * t
                    val group_by :
                      t -> equiv:(edge -> edge -> bool) -> t list
                    val find_exn : t -> f:(edge -> bool) -> edge
                    val find_index : t -> int -> edge option
                    val nth : t -> int -> edge option
                    val remove_index : t -> int -> t
                    val to_tree : t -> t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:edge ->
                      ?less_or_equal_to:edge ->
                      t ->
                      t ->
                      (edge, edge)
                      Base__.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(edge -> 'data) ->
                      (edge, 'data, comparator_witness) Core_kernel__.Map.t
                    val obs :
                      edge Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      edge Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : edge -> t
                    val union_list : t list -> t
                    val of_list : edge list -> t
                    val of_array : edge array -> t
                    val of_sorted_array : edge array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : edge array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> edge) -> t
                    val stable_dedup_list : edge list -> edge list
                    val map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge) -> t
                    val filter_map :
                      ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                      f:('a -> edge option) -> t
                    val of_tree : t -> t
                    val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                    val of_map_keys :
                      (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                    val gen :
                      edge Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> edge
                               end) ->
                        sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                    val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                  end
                type t = (edge, comparator_witness) Base.Set.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (edge, comparator_witness) Core_kernel__.Set_intf.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(edge -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(edge -> bool) -> bool
                val for_all : t -> f:(edge -> bool) -> bool
                val count : t -> f:(edge -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(edge -> 'sum) -> 'sum
                val find : t -> f:(edge -> bool) -> edge option
                val find_map : t -> f:(edge -> 'a option) -> 'a option
                val to_list : t -> edge list
                val to_array : t -> edge array
                val invariants : t -> bool
                val mem : t -> edge -> bool
                val add : t -> edge -> t
                val remove : t -> edge -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     edge -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of edge * edge | `Left of edge | `Right of edge ] ->
                     unit) ->
                  unit
                val filter : t -> f:(edge -> bool) -> t
                val partition_tf : t -> f:(edge -> bool) -> t * t
                val elements : t -> edge list
                val min_elt : t -> edge option
                val min_elt_exn : t -> edge
                val max_elt : t -> edge option
                val max_elt_exn : t -> edge
                val choose : t -> edge option
                val choose_exn : t -> edge
                val split : t -> edge -> t * edge option * t
                val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                val find_exn : t -> f:(edge -> bool) -> edge
                val find_index : t -> int -> edge option
                val nth : t -> int -> edge option
                val remove_index : t -> int -> t
                val to_tree : t -> Tree.t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:edge ->
                  ?less_or_equal_to:edge ->
                  t ->
                  t ->
                  (edge, edge) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(edge -> 'data) ->
                  (edge, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  edge Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  edge Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : edge -> t
                val union_list : t list -> t
                val of_list : edge list -> t
                val of_array : edge array -> t
                val of_sorted_array : edge array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : edge array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> edge) -> t
                val stable_dedup_list : edge list -> edge list
                val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
                val filter_map :
                  ('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
                val of_tree : Tree.t -> t
                val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (edge, 'a) Node.Table.hashtbl -> t
                val of_map_keys :
                  (edge, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  edge Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> edge
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (Elt : sig
                             val bin_t : edge Bin_prot.Type_class.t
                             val bin_read_t : edge Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> edge)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               edge Bin_prot.Type_class.reader
                             val bin_size_t : edge Bin_prot.Size.sizer
                             val bin_write_t : edge Bin_prot.Write.writer
                             val bin_writer_t :
                               edge Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                module Provide_hash :
                  functor
                    (Elt : sig
                             val hash_fold_t :
                               Base__.Hash.state -> edge -> Base__.Hash.state
                           end) ->
                    sig
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                    end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            val compare : t -> t -> Core_kernel__.Import.int
            val hash_fold_t :
              Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
            val hashable : t Core_kernel__.Hashtbl.Hashable.t
            module Table :
              sig
                type key = t
                type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                type 'b t = (key, 'b) hashtbl
                val sexp_of_t :
                  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'b t -> Ppx_sexp_conv_lib.Sexp.t
                type ('a, 'b) t_ = 'b t
                type 'a key_ = key
                val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
                val invariant :
                  'a Base__.Invariant_intf.inv ->
                  'a t Base__.Invariant_intf.inv
                val create :
                  (key, 'b, unit -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist :
                  (key, 'b,
                   (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_report_all_dups :
                  (key, 'b,
                   (key * 'b) list ->
                   [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_or_error :
                  (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_exn :
                  (key, 'b, (key * 'b) list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val of_alist_multi :
                  (key, 'b list, (key * 'b) list -> 'b list t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_mapped :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key :
                  (key, 'r,
                   get_key:('r -> key) ->
                   'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_or_error :
                  (key, 'r,
                   get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val create_with_key_exn :
                  (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val group :
                  (key, 'b,
                   get_key:('r -> key) ->
                   get_data:('r -> 'b) ->
                   combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
                  Core_kernel__.Hashtbl_intf.create_options_without_hashable
                val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                val clear : 'a t -> unit
                val copy : 'b t -> 'b t
                val fold :
                  'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
                val iter_keys : 'a t -> f:(key -> unit) -> unit
                val iter : 'b t -> f:('b -> unit) -> unit
                val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
                val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val exists : 'b t -> f:('b -> bool) -> bool
                val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
                val for_all : 'b t -> f:('b -> bool) -> bool
                val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
                val count : 'b t -> f:('b -> bool) -> int
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val remove : 'a t -> key -> unit
                val set : 'b t -> key:key -> data:'b -> unit
                val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
                val add_exn : 'b t -> key:key -> data:'b -> unit
                val change :
                  'b t -> key -> f:('b option -> 'b option) -> unit
                val update : 'b t -> key -> f:('b option -> 'b) -> unit
                val map : 'b t -> f:('b -> 'c) -> 'c t
                val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
                val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
                val filter_mapi :
                  'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
                val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                val filter : 'b t -> f:('b -> bool) -> 'b t
                val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
                val partition_map :
                  'b t ->
                  f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
                val partition_mapi :
                  'b t ->
                  f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
                  'c t * 'd t
                val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
                val partitioni_tf :
                  'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
                val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
                val find : 'b t -> key -> 'b option
                val find_exn : 'b t -> key -> 'b
                val find_and_call :
                  'b t ->
                  key ->
                  if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
                val findi_and_call :
                  'b t ->
                  key ->
                  if_found:(key:key -> data:'b -> 'c) ->
                  if_not_found:(key -> 'c) -> 'c
                val find_and_remove : 'b t -> key -> 'b option
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:key ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                type 'a merge_into_action = Remove | Set_to of 'a
                val merge_into :
                  src:'a t ->
                  dst:'b t ->
                  f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
                  unit
                val keys : 'a t -> key list
                val data : 'b t -> 'b list
                val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                val filter_inplace : 'b t -> f:('b -> bool) -> unit
                val filteri_inplace :
                  'b t -> f:(key:key -> data:'b -> bool) -> unit
                val map_inplace : 'b t -> f:('b -> 'b) -> unit
                val mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b) -> unit
                val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
                val filter_mapi_inplace :
                  'b t -> f:(key:key -> data:'b -> 'b option) -> unit
                val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
                val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                val to_alist : 'b t -> (key * 'b) list
                val validate :
                  name:(key -> string) ->
                  'b Base__.Validate.check -> 'b t Base__.Validate.check
                val incr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val decr :
                  ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                val add_multi : 'b list t -> key:key -> data:'b -> unit
                val remove_multi : 'a list t -> key -> unit
                val find_multi : 'b list t -> key -> 'b list
                module Provide_of_sexp :
                  functor
                    (Key : sig
                             val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                           end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                    end
                module Provide_bin_io :
                  functor
                    (Key : sig
                             val bin_t : key Bin_prot.Type_class.t
                             val bin_read_t : key Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> key)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               key Bin_prot.Type_class.reader
                             val bin_size_t : key Bin_prot.Size.sizer
                             val bin_write_t : key Bin_prot.Write.writer
                             val bin_writer_t :
                               key Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end) ->
                    sig
                      val bin_t :
                        'a Bin_prot.Type_class.t ->
                        'a t Bin_prot.Type_class.t
                      val bin_read_t :
                        'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'a Bin_prot.Read.reader ->
                        (Core_kernel__.Import.int -> 'a t)
                        Bin_prot.Read.reader
                      val bin_reader_t :
                        'a Bin_prot.Type_class.reader ->
                        'a t Bin_prot.Type_class.reader
                      val bin_size_t :
                        'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                      val bin_write_t :
                        'a Bin_prot.Write.writer ->
                        'a t Bin_prot.Write.writer
                      val bin_writer_t :
                        'a Bin_prot.Type_class.writer ->
                        'a t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    end
                val t_of_sexp :
                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
              end
            module Hash_set :
              sig
                type elt = t
                type t = elt Core_kernel__.Hash_set.t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type 'a t_ = t
                type 'a elt_ = elt
                val create :
                  ('a, unit -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                val of_list :
                  ('a, elt list -> t)
                  Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                module Provide_of_sexp :
                  functor
                    (X : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt
                         end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                module Provide_bin_io :
                  functor
                    (X : sig
                           val bin_t : elt Bin_prot.Type_class.t
                           val bin_read_t : elt Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> elt)
                             Bin_prot.Read.reader
                           val bin_reader_t : elt Bin_prot.Type_class.reader
                           val bin_size_t : elt Bin_prot.Size.sizer
                           val bin_write_t : elt Bin_prot.Write.writer
                           val bin_writer_t : elt Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end) ->
                    sig
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                    end
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
              end
            module Hash_queue :
              sig
                module Key :
                  sig
                    type t = edge
                    val compare : t -> t -> int
                    val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                    val hash : t -> int
                  end
                type 'a t
                val sexp_of_t :
                  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Ppx_sexp_conv_lib.Sexp.t
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('a -> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     'a ->
                     ('accum, 'final)
                     Base__.Container_intf.Continue_or_stop.t) ->
                  finish:('accum -> 'final) -> 'final
                val exists : 'a t -> f:('a -> bool) -> bool
                val for_all : 'a t -> f:('a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('a -> 'sum) -> 'sum
                val find : 'a t -> f:('a -> bool) -> 'a option
                val find_map : 'a t -> f:('a -> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
                val invariant : 'a t -> Core_kernel__.Import.unit
                val create :
                  ?growth_allowed:Core_kernel__.Import.bool ->
                  ?size:Core_kernel__.Import.int ->
                  Core_kernel__.Import.unit -> 'a t
                val clear : 'a t -> Core_kernel__.Import.unit
                val mem : 'a t -> edge -> Core_kernel__.Import.bool
                val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_exn : 'a t -> edge -> 'a
                val enqueue :
                  'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
                val enqueue_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val lookup_and_move_to_back :
                  'a t -> edge -> 'a Core_kernel__.Import.option
                val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                val first : 'a t -> 'a Core_kernel__.Import.option
                val first_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val keys : 'a t -> edge Core_kernel__.Import.list
                val dequeue : 'a t -> 'a Core_kernel__.Import.option
                val dequeue_exn : 'a t -> 'a
                val dequeue_with_key :
                  'a t -> (edge * 'a) Core_kernel__.Import.option
                val dequeue_with_key_exn : 'a t -> edge * 'a
                val dequeue_all :
                  'a t ->
                  f:('a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
                val replace_exn :
                  'a t -> edge -> 'a -> Core_kernel__.Import.unit
                val iteri :
                  'a t ->
                  f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
                  Core_kernel__.Import.unit
                val foldi :
                  'a t ->
                  init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
              end
          end
        val empty : t
        val nodes : t -> node Regular.Std.seq
        val edges : t -> edge Regular.Std.seq
        val is_directed : bool
        val number_of_edges : t -> int
        val number_of_nodes : t -> int
        val ( >= ) : t -> t -> bool
        val ( <= ) : t -> t -> bool
        val ( = ) : t -> t -> bool
        val ( > ) : t -> t -> bool
        val ( < ) : t -> t -> bool
        val ( <> ) : t -> t -> bool
        val equal : t -> t -> bool
        val min : t -> t -> t
        val max : t -> t -> t
        val ascending : t -> t -> int
        val descending : t -> t -> int
        val between : t -> low:t -> high:t -> bool
        val clamp_exn : t -> min:t -> max:t -> t
        val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
        type comparator_witness
        val comparator : (t, comparator_witness) Base__.Comparator.comparator
        val validate_lbound :
          min:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_ubound :
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        val validate_bound :
          min:t Base__.Maybe_bound.t ->
          max:t Base__.Maybe_bound.t -> t Base__.Validate.check
        module Replace_polymorphic_compare :
          sig
            val ( >= ) : t -> t -> bool
            val ( <= ) : t -> t -> bool
            val ( = ) : t -> t -> bool
            val ( > ) : t -> t -> bool
            val ( < ) : t -> t -> bool
            val ( <> ) : t -> t -> bool
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val min : t -> t -> t
            val max : t -> t -> t
          end
        module Map :
          sig
            module Key :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type 'a t =
                    (Key.t, 'a, comparator_witness)
                    Core_kernel__.Map_intf.Tree.t
                val empty : 'a t
                val singleton : Key.t -> 'a -> 'a t
                val of_alist :
                  (Key.t * 'a) list ->
                  [ `Duplicate_key of Key.t | `Ok of 'a t ]
                val of_alist_or_error :
                  (Key.t * 'a) list -> 'a t Base__.Or_error.t
                val of_alist_exn : (Key.t * 'a) list -> 'a t
                val of_alist_multi : (Key.t * 'a) list -> 'a list t
                val of_alist_fold :
                  (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
                val of_alist_reduce :
                  (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
                val of_sorted_array :
                  (Key.t * 'a) array -> 'a t Base__.Or_error.t
                val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Key.t * 'a) -> 'a t
                val of_increasing_sequence :
                  (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                val of_iteri :
                  iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
                  [ `Duplicate_key of Key.t | `Ok of 'v t ]
                val of_tree : 'a t -> 'a t
                val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
                val gen :
                  Key.t Core_kernel__.Quickcheck.Generator.t ->
                  'a Core_kernel__.Quickcheck.Generator.t ->
                  'a t Core_kernel__.Quickcheck.Generator.t
                val invariants : 'a t -> bool
                val is_empty : 'a t -> bool
                val length : 'a t -> int
                val add :
                  'a t ->
                  key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
                val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
                val set : 'a t -> key:Key.t -> data:'a -> 'a t
                val add_multi :
                  'a list t -> key:Key.t -> data:'a -> 'a list t
                val remove_multi : 'a list t -> Key.t -> 'a list t
                val find_multi : 'a list t -> Key.t -> 'a list
                val change :
                  'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                val find : 'a t -> Key.t -> 'a option
                val find_exn : 'a t -> Key.t -> 'a
                val remove : 'a t -> Key.t -> 'a t
                val mem : 'a t -> Key.t -> bool
                val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                val iter : 'a t -> f:('a -> unit) -> unit
                val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
                val iter2 :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     unit) ->
                  unit
                val map : 'a t -> f:('a -> 'b) -> 'b t
                val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
                val fold :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold_right :
                  'a t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val fold2 :
                  'a t ->
                  'b t ->
                  init:'c ->
                  f:(key:Key.t ->
                     data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c -> 'c) ->
                  'c
                val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                val filter : 'a t -> f:('a -> bool) -> 'a t
                val filteri :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
                val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
                val partition_mapi :
                  'a t ->
                  f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
                  'b t * 'c t
                val partition_map :
                  'a t ->
                  f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
                val partitioni_tf :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
                val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
                val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
                val keys : 'a t -> Key.t list
                val data : 'a t -> 'a list
                val to_alist :
                  ?key_order:[ `Decreasing | `Increasing ] ->
                  'a t -> (Key.t * 'a) list
                val validate :
                  name:(Key.t -> string) ->
                  'a Base__.Validate.check -> 'a t Base__.Validate.check
                val merge :
                  'a t ->
                  'b t ->
                  f:(key:Key.t ->
                     [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                     'c option) ->
                  'c t
                val symmetric_diff :
                  'a t ->
                  'a t ->
                  data_equal:('a -> 'a -> bool) ->
                  (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
                  Base__.Sequence.t
                val min_elt : 'a t -> (Key.t * 'a) option
                val min_elt_exn : 'a t -> Key.t * 'a
                val max_elt : 'a t -> (Key.t * 'a) option
                val max_elt_exn : 'a t -> Key.t * 'a
                val for_all : 'a t -> f:('a -> bool) -> bool
                val for_alli :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val exists : 'a t -> f:('a -> bool) -> bool
                val existsi :
                  'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
                val count : 'a t -> f:('a -> bool) -> int
                val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
                val split :
                  'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                val append :
                  lower_part:'a t ->
                  upper_part:'a t ->
                  [ `Ok of 'a t | `Overlapping_key_ranges ]
                val subrange :
                  'a t ->
                  lower_bound:Key.t Base__.Maybe_bound.t ->
                  upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                val fold_range_inclusive :
                  'a t ->
                  min:Key.t ->
                  max:Key.t ->
                  init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
                val range_to_alist :
                  'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                val closest_key :
                  'a t ->
                  [ `Greater_or_equal_to
                  | `Greater_than
                  | `Less_or_equal_to
                  | `Less_than ] -> Key.t -> (Key.t * 'a) option
                val nth : 'a t -> int -> (Key.t * 'a) option
                val nth_exn : 'a t -> int -> Key.t * 'a
                val rank : 'a t -> Key.t -> int option
                val to_tree : 'a t -> 'a t
                val to_sequence :
                  ?order:[ `Decreasing_key | `Increasing_key ] ->
                  ?keys_greater_or_equal_to:Key.t ->
                  ?keys_less_or_equal_to:Key.t ->
                  'a t -> (Key.t * 'a) Base__.Sequence.t
                val obs :
                  Key.t Core_kernel__.Quickcheck.Observer.t ->
                  'v Core_kernel__.Quickcheck.Observer.t ->
                  'v t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                  'v Core_kernel__.Quickcheck.Shrinker.t ->
                  'v t Core_kernel__.Quickcheck.Shrinker.t
                module Provide_of_sexp :
                  functor
                    (K : sig
                           val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                         end) ->
                    sig
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                    end
                val t_of_sexp :
                  (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                  Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                  'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type 'a t =
                (Key.t, 'a, comparator_witness) Core_kernel__.Map_intf.Map.t
            val compare :
              ('a -> 'a -> Core_kernel__.Import.int) ->
              'a t -> 'a t -> Core_kernel__.Import.int
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_or_error :
              (Key.t * 'a) list -> 'a t Base__.Or_error.t
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_alist_reduce :
              (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
            val of_sorted_array :
              (Key.t * 'a) array -> 'a t Base__.Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Key.t * 'a) -> 'a t
            val of_increasing_sequence :
              (Key.t * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
            val of_iteri :
              iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
              [ `Duplicate_key of Key.t | `Ok of 'v t ]
            val of_tree : 'a Tree.t -> 'a t
            val of_hashtbl_exn : (Key.t, 'a) Edge.Table.hashtbl -> 'a t
            val gen :
              Key.t Core_kernel__.Quickcheck.Generator.t ->
              'a Core_kernel__.Quickcheck.Generator.t ->
              'a t Core_kernel__.Quickcheck.Generator.t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add :
              'a t ->
              key:Key.t -> data:'a -> 'a t Base__.Map_intf.Or_duplicate.t
            val add_exn : 'a t -> key:Key.t -> data:'a -> 'a t
            val set : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val remove_multi : 'a list t -> Key.t -> 'a list t
            val find_multi : 'a list t -> Key.t -> 'a list
            val change : 'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
            val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
            val iter : 'a t -> f:('a -> unit) -> unit
            val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold2 :
              'a t ->
              'b t ->
              init:'c ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c -> 'c) ->
              'c
            val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
            val filter : 'a t -> f:('a -> bool) -> 'a t
            val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val partition_mapi :
              'a t ->
              f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
              'b t * 'c t
            val partition_map :
              'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
            val partitioni_tf :
              'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
            val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist :
              ?key_order:[ `Decreasing | `Increasing ] ->
              'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Base__.Validate.check -> 'a t Base__.Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t, 'a) Base__.Map_intf.Symmetric_diff_element.t
              Base__.Sequence.t
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
            val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
            val append :
              lower_part:'a t ->
              upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
            val subrange :
              'a t ->
              lower_bound:Key.t Base__.Maybe_bound.t ->
              upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val closest_key :
              'a t ->
              [ `Greater_or_equal_to
              | `Greater_than
              | `Less_or_equal_to
              | `Less_than ] -> Key.t -> (Key.t * 'a) option
            val nth : 'a t -> int -> (Key.t * 'a) option
            val nth_exn : 'a t -> int -> Key.t * 'a
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a Tree.t
            val to_sequence :
              ?order:[ `Decreasing_key | `Increasing_key ] ->
              ?keys_greater_or_equal_to:Key.t ->
              ?keys_less_or_equal_to:Key.t ->
              'a t -> (Key.t * 'a) Base__.Sequence.t
            val obs :
              Key.t Core_kernel__.Quickcheck.Observer.t ->
              'v Core_kernel__.Quickcheck.Observer.t ->
              'v t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Key.t Core_kernel__.Quickcheck.Shrinker.t ->
              'v Core_kernel__.Quickcheck.Shrinker.t ->
              'v t Core_kernel__.Quickcheck.Shrinker.t
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Key.t
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : Key.t Bin_prot.Type_class.t
                         val bin_read_t : Key.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Key.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Key.t Bin_prot.Type_class.reader
                         val bin_size_t : Key.t Bin_prot.Size.sizer
                         val bin_write_t : Key.t Bin_prot.Write.writer
                         val bin_writer_t : Key.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
            module Provide_hash :
              functor
                (Key : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Key.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    (Ppx_hash_lib.Std.Hash.state ->
                     'a -> Ppx_hash_lib.Std.Hash.state) ->
                    Ppx_hash_lib.Std.Hash.state ->
                    'a t -> Ppx_hash_lib.Std.Hash.state
                end
            val t_of_sexp :
              (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
              Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
            val sexp_of_t :
              ('a -> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        module Set :
          sig
            module Elt :
              sig
                type t = Edge.graph
                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                type comparator_witness = Map.Key.comparator_witness
                val comparator :
                  (t, comparator_witness) Core_kernel__.Comparator.comparator
              end
            module Tree :
              sig
                type t =
                    (Elt.t, comparator_witness) Core_kernel__.Set_intf.Tree.t
                val compare : t -> t -> Core_kernel__.Import.int
                type named =
                    (Elt.t, comparator_witness)
                    Core_kernel__.Set_intf.Tree.Named.t
                val length : t -> int
                val is_empty : t -> bool
                val iter : t -> f:(Elt.t -> unit) -> unit
                val fold :
                  t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                val fold_result :
                  t ->
                  init:'accum ->
                  f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val exists : t -> f:(Elt.t -> bool) -> bool
                val for_all : t -> f:(Elt.t -> bool) -> bool
                val count : t -> f:(Elt.t -> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  t -> f:(Elt.t -> 'sum) -> 'sum
                val find : t -> f:(Elt.t -> bool) -> Elt.t option
                val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                val to_list : t -> Elt.t list
                val to_array : t -> Elt.t array
                val invariants : t -> bool
                val mem : t -> Elt.t -> bool
                val add : t -> Elt.t -> t
                val remove : t -> Elt.t -> t
                val union : t -> t -> t
                val inter : t -> t -> t
                val diff : t -> t -> t
                val symmetric_diff :
                  t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                val compare_direct : t -> t -> int
                val equal : t -> t -> bool
                val is_subset : t -> of_:t -> bool
                val subset : t -> t -> bool
                module Named :
                  sig
                    val is_subset :
                      named -> of_:named -> unit Base__.Or_error.t
                    val equal : named -> named -> unit Base__.Or_error.t
                  end
                val fold_until :
                  t ->
                  init:'b ->
                  f:('b ->
                     Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                  finish:('b -> 'final) -> 'final
                val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
                val iter2 :
                  t ->
                  t ->
                  f:([ `Both of Elt.t * Elt.t
                     | `Left of Elt.t
                     | `Right of Elt.t ] -> unit) ->
                  unit
                val filter : t -> f:(Elt.t -> bool) -> t
                val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                val elements : t -> Elt.t list
                val min_elt : t -> Elt.t option
                val min_elt_exn : t -> Elt.t
                val max_elt : t -> Elt.t option
                val max_elt_exn : t -> Elt.t
                val choose : t -> Elt.t option
                val choose_exn : t -> Elt.t
                val split : t -> Elt.t -> t * Elt.t option * t
                val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                val find_index : t -> int -> Elt.t option
                val nth : t -> int -> Elt.t option
                val remove_index : t -> int -> t
                val to_tree : t -> t
                val to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                val merge_to_sequence :
                  ?order:[ `Decreasing | `Increasing ] ->
                  ?greater_or_equal_to:Elt.t ->
                  ?less_or_equal_to:Elt.t ->
                  t ->
                  t ->
                  (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
                  Base__.Sequence.t
                val to_map :
                  t ->
                  f:(Elt.t -> 'data) ->
                  (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
                val obs :
                  Elt.t Core_kernel__.Quickcheck.Observer.t ->
                  t Core_kernel__.Quickcheck.Observer.t
                val shrinker :
                  Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                  t Core_kernel__.Quickcheck.Shrinker.t
                val empty : t
                val singleton : Elt.t -> t
                val union_list : t list -> t
                val of_list : Elt.t list -> t
                val of_array : Elt.t array -> t
                val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                val of_sorted_array_unchecked : Elt.t array -> t
                val of_increasing_iterator_unchecked :
                  len:int -> f:(int -> Elt.t) -> t
                val stable_dedup_list : Elt.t list -> Elt.t list
                val map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t) -> t
                val filter_map :
                  ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                  f:('a -> Elt.t option) -> t
                val of_tree : t -> t
                val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
                val of_map_keys :
                  (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
                val gen :
                  Elt.t Core_kernel__.Quickcheck.Generator.t ->
                  t Core_kernel__.Quickcheck.Generator.t
                module Provide_of_sexp :
                  functor
                    (Elt : sig
                             val t_of_sexp :
                               Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                           end) ->
                    sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
                val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
              end
            type t = (Elt.t, comparator_witness) Base.Set.t
            val compare : t -> t -> Core_kernel__.Import.int
            type named =
                (Elt.t, comparator_witness) Core_kernel__.Set_intf.Named.t
            val length : t -> int
            val is_empty : t -> bool
            val iter : t -> f:(Elt.t -> unit) -> unit
            val fold :
              t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
            val fold_result :
              t ->
              init:'accum ->
              f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val exists : t -> f:(Elt.t -> bool) -> bool
            val for_all : t -> f:(Elt.t -> bool) -> bool
            val count : t -> f:(Elt.t -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              t -> f:(Elt.t -> 'sum) -> 'sum
            val find : t -> f:(Elt.t -> bool) -> Elt.t option
            val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
            val to_list : t -> Elt.t list
            val to_array : t -> Elt.t array
            val invariants : t -> bool
            val mem : t -> Elt.t -> bool
            val add : t -> Elt.t -> t
            val remove : t -> Elt.t -> t
            val union : t -> t -> t
            val inter : t -> t -> t
            val diff : t -> t -> t
            val symmetric_diff :
              t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
            val compare_direct : t -> t -> int
            val equal : t -> t -> bool
            val is_subset : t -> of_:t -> bool
            val subset : t -> t -> bool
            module Named :
              sig
                val is_subset : named -> of_:named -> unit Base__.Or_error.t
                val equal : named -> named -> unit Base__.Or_error.t
              end
            val fold_until :
              t ->
              init:'b ->
              f:('b ->
                 Elt.t -> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
              finish:('b -> 'final) -> 'final
            val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
            val iter2 :
              t ->
              t ->
              f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
                 unit) ->
              unit
            val filter : t -> f:(Elt.t -> bool) -> t
            val partition_tf : t -> f:(Elt.t -> bool) -> t * t
            val elements : t -> Elt.t list
            val min_elt : t -> Elt.t option
            val min_elt_exn : t -> Elt.t
            val max_elt : t -> Elt.t option
            val max_elt_exn : t -> Elt.t
            val choose : t -> Elt.t option
            val choose_exn : t -> Elt.t
            val split : t -> Elt.t -> t * Elt.t option * t
            val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
            val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
            val find_index : t -> int -> Elt.t option
            val nth : t -> int -> Elt.t option
            val remove_index : t -> int -> t
            val to_tree : t -> Tree.t
            val to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
            val merge_to_sequence :
              ?order:[ `Decreasing | `Increasing ] ->
              ?greater_or_equal_to:Elt.t ->
              ?less_or_equal_to:Elt.t ->
              t ->
              t ->
              (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t
              Base__.Sequence.t
            val to_map :
              t ->
              f:(Elt.t -> 'data) ->
              (Elt.t, 'data, comparator_witness) Core_kernel__.Map.t
            val obs :
              Elt.t Core_kernel__.Quickcheck.Observer.t ->
              t Core_kernel__.Quickcheck.Observer.t
            val shrinker :
              Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
              t Core_kernel__.Quickcheck.Shrinker.t
            val empty : t
            val singleton : Elt.t -> t
            val union_list : t list -> t
            val of_list : Elt.t list -> t
            val of_array : Elt.t array -> t
            val of_sorted_array : Elt.t array -> t Base__.Or_error.t
            val of_sorted_array_unchecked : Elt.t array -> t
            val of_increasing_iterator_unchecked :
              len:int -> f:(int -> Elt.t) -> t
            val stable_dedup_list : Elt.t list -> Elt.t list
            val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
            val of_tree : Tree.t -> t
            val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
            val of_hashtbl_keys : (Elt.t, 'a) Edge.Table.hashtbl -> t
            val of_map_keys :
              (Elt.t, 'a, comparator_witness) Core_kernel__.Map.t -> t
            val gen :
              Elt.t Core_kernel__.Quickcheck.Generator.t ->
              t Core_kernel__.Quickcheck.Generator.t
            module Provide_of_sexp :
              functor
                (Elt : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> Elt.t
                       end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (Elt : sig
                         val bin_t : Elt.t Bin_prot.Type_class.t
                         val bin_read_t : Elt.t Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> Elt.t)
                           Bin_prot.Read.reader
                         val bin_reader_t : Elt.t Bin_prot.Type_class.reader
                         val bin_size_t : Elt.t Bin_prot.Size.sizer
                         val bin_write_t : Elt.t Bin_prot.Write.writer
                         val bin_writer_t : Elt.t Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
            module Provide_hash :
              functor
                (Elt : sig
                         val hash_fold_t :
                           Base__.Hash.state -> Elt.t -> Base__.Hash.state
                       end) ->
                sig
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                end
            val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
            val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
          end
        val compare : t -> t -> Core_kernel__.Import.int
        val hash_fold_t :
          Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
        val hashable : t Core_kernel__.Hashtbl.Hashable.t
        module Table :
          sig
            type key = t
            type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
            type 'b t = (key, 'b) hashtbl
            val sexp_of_t :
              ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
              'b t -> Ppx_sexp_conv_lib.Sexp.t
            type ('a, 'b) t_ = 'b t
            type 'a key_ = key
            val hashable : key Core_kernel__.Hashtbl_intf.Hashable.t
            val invariant :
              'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
            val create :
              (key, 'b, unit -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist :
              (key, 'b,
               (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_report_all_dups :
              (key, 'b,
               (key * 'b) list ->
               [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_or_error :
              (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_exn :
              (key, 'b, (key * 'b) list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val of_alist_multi :
              (key, 'b list, (key * 'b) list -> 'b list t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_mapped :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key :
              (key, 'r,
               get_key:('r -> key) ->
               'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_or_error :
              (key, 'r,
               get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val create_with_key_exn :
              (key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val group :
              (key, 'b,
               get_key:('r -> key) ->
               get_data:('r -> 'b) ->
               combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
              Core_kernel__.Hashtbl_intf.create_options_without_hashable
            val sexp_of_key : 'a t -> key -> Base__.Sexp.t
            val clear : 'a t -> unit
            val copy : 'b t -> 'b t
            val fold :
              'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
            val iter_keys : 'a t -> f:(key -> unit) -> unit
            val iter : 'b t -> f:('b -> unit) -> unit
            val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
            val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val exists : 'b t -> f:('b -> bool) -> bool
            val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
            val for_all : 'b t -> f:('b -> bool) -> bool
            val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
            val count : 'b t -> f:('b -> bool) -> int
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val mem : 'a t -> key -> bool
            val remove : 'a t -> key -> unit
            val set : 'b t -> key:key -> data:'b -> unit
            val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
            val add_exn : 'b t -> key:key -> data:'b -> unit
            val change : 'b t -> key -> f:('b option -> 'b option) -> unit
            val update : 'b t -> key -> f:('b option -> 'b) -> unit
            val map : 'b t -> f:('b -> 'c) -> 'c t
            val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
            val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
            val filter_mapi :
              'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
            val filter_keys : 'b t -> f:(key -> bool) -> 'b t
            val filter : 'b t -> f:('b -> bool) -> 'b t
            val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
            val partition_map :
              'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
            val partition_mapi :
              'b t ->
              f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
              'c t * 'd t
            val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
            val partitioni_tf :
              'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
            val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
            val findi_or_add : 'b t -> key -> default:(key -> 'b) -> 'b
            val find : 'b t -> key -> 'b option
            val find_exn : 'b t -> key -> 'b
            val find_and_call :
              'b t ->
              key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
            val findi_and_call :
              'b t ->
              key ->
              if_found:(key:key -> data:'b -> 'c) ->
              if_not_found:(key -> 'c) -> 'c
            val find_and_remove : 'b t -> key -> 'b option
            val merge :
              'a t ->
              'b t ->
              f:(key:key ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            type 'a merge_into_action = Remove | Set_to of 'a
            val merge_into :
              src:'a t ->
              dst:'b t ->
              f:(key:key -> 'a -> 'b option -> 'b merge_into_action) -> unit
            val keys : 'a t -> key list
            val data : 'b t -> 'b list
            val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
            val filter_inplace : 'b t -> f:('b -> bool) -> unit
            val filteri_inplace :
              'b t -> f:(key:key -> data:'b -> bool) -> unit
            val map_inplace : 'b t -> f:('b -> 'b) -> unit
            val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
            val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
            val filter_mapi_inplace :
              'b t -> f:(key:key -> data:'b -> 'b option) -> unit
            val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
            val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
            val to_alist : 'b t -> (key * 'b) list
            val validate :
              name:(key -> string) ->
              'b Base__.Validate.check -> 'b t Base__.Validate.check
            val incr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val decr :
              ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
            val add_multi : 'b list t -> key:key -> data:'b -> unit
            val remove_multi : 'a list t -> key -> unit
            val find_multi : 'b list t -> key -> 'b list
            module Provide_of_sexp :
              functor
                (Key : sig
                         val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> key
                       end) ->
                sig
                  val t_of_sexp :
                    (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                    Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                end
            module Provide_bin_io :
              functor
                (Key : sig
                         val bin_t : key Bin_prot.Type_class.t
                         val bin_read_t : key Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> key)
                           Bin_prot.Read.reader
                         val bin_reader_t : key Bin_prot.Type_class.reader
                         val bin_size_t : key Bin_prot.Size.sizer
                         val bin_write_t : key Bin_prot.Write.writer
                         val bin_writer_t : key Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end) ->
                sig
                  val bin_t :
                    'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                  val bin_read_t :
                    'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'a Bin_prot.Read.reader ->
                    (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                  val bin_reader_t :
                    'a Bin_prot.Type_class.reader ->
                    'a t Bin_prot.Type_class.reader
                  val bin_size_t :
                    'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                  val bin_write_t :
                    'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                  val bin_writer_t :
                    'a Bin_prot.Type_class.writer ->
                    'a t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                end
            val t_of_sexp :
              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
          end
        module Hash_set :
          sig
            type elt = t
            type t = elt Core_kernel__.Hash_set.t
            val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
            type 'a t_ = t
            type 'a elt_ = elt
            val create :
              ('a, unit -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            val of_list :
              ('a, elt list -> t)
              Core_kernel__.Hash_set_intf.create_options_without_first_class_module
            module Provide_of_sexp :
              functor
                (X : sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> elt end) ->
                sig val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t end
            module Provide_bin_io :
              functor
                (X : sig
                       val bin_t : elt Bin_prot.Type_class.t
                       val bin_read_t : elt Bin_prot.Read.reader
                       val __bin_read_t__ :
                         (Core_kernel__.Import.int -> elt)
                         Bin_prot.Read.reader
                       val bin_reader_t : elt Bin_prot.Type_class.reader
                       val bin_size_t : elt Bin_prot.Size.sizer
                       val bin_write_t : elt Bin_prot.Write.writer
                       val bin_writer_t : elt Bin_prot.Type_class.writer
                       val bin_shape_t : Bin_prot.Shape.t
                     end) ->
                sig
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                end
            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
          end
        module Hash_queue :
          sig
            module Key :
              sig
                type t = Hash_set.elt
                val compare : t -> t -> int
                val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                val hash : t -> int
              end
            type 'a t
            val sexp_of_t :
              ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
              'a t -> Ppx_sexp_conv_lib.Sexp.t
            val length : 'a t -> int
            val is_empty : 'a t -> bool
            val iter : 'a t -> f:('a -> unit) -> unit
            val fold :
              'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
            val fold_result :
              'a t ->
              init:'accum ->
              f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
              ('accum, 'e) Base__.Result.t
            val fold_until :
              'a t ->
              init:'accum ->
              f:('accum ->
                 'a ->
                 ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ->
              finish:('accum -> 'final) -> 'final
            val exists : 'a t -> f:('a -> bool) -> bool
            val for_all : 'a t -> f:('a -> bool) -> bool
            val count : 'a t -> f:('a -> bool) -> int
            val sum :
              (module Base__.Commutative_group.S with type t = 'sum) ->
              'a t -> f:('a -> 'sum) -> 'sum
            val find : 'a t -> f:('a -> bool) -> 'a option
            val find_map : 'a t -> f:('a -> 'b option) -> 'b option
            val to_list : 'a t -> 'a list
            val to_array : 'a t -> 'a array
            val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
            val invariant : 'a t -> Core_kernel__.Import.unit
            val create :
              ?growth_allowed:Core_kernel__.Import.bool ->
              ?size:Core_kernel__.Import.int ->
              Core_kernel__.Import.unit -> 'a t
            val clear : 'a t -> Core_kernel__.Import.unit
            val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
            val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_exn : 'a t -> Key.t -> 'a
            val enqueue :
              'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
            val enqueue_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val lookup_and_move_to_back :
              'a t -> Key.t -> 'a Core_kernel__.Import.option
            val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
            val first : 'a t -> 'a Core_kernel__.Import.option
            val first_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val keys : 'a t -> Key.t Core_kernel__.Import.list
            val dequeue : 'a t -> 'a Core_kernel__.Import.option
            val dequeue_exn : 'a t -> 'a
            val dequeue_with_key :
              'a t -> (Key.t * 'a) Core_kernel__.Import.option
            val dequeue_with_key_exn : 'a t -> Key.t * 'a
            val dequeue_all :
              'a t ->
              f:('a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
            val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
            val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
            val replace_exn :
              'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
            val iteri :
              'a t ->
              f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
              Core_kernel__.Import.unit
            val foldi :
              'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
          end
        val to_string : t -> string
        val str : unit -> t -> string
        val pps : unit -> t -> string
        val ppo : Core_kernel.Out_channel.t -> t -> unit
        val pp_seq : Format.formatter -> t Core_kernel.Sequence.t -> unit
        val pp : Base__.Formatter.t -> t -> unit
      end
  val fixpoint :
    (module Graphlib.Std.Graph with type node = 'n and type t = 'c) ->
    ?steps:int ->
    ?start:'n ->
    ?rev:bool ->
    ?step:(int -> 'n -> 'd -> 'd -> 'd) ->
    init:('n, 'd) Graphlib.Std.Solution.t ->
    equal:('d -> 'd -> bool) ->
    merge:('d -> 'd -> 'd) ->
    f:('n -> 'd -> 'd) -> 'c -> ('n, 'd) Graphlib.Std.Solution.t
  type scheme
  type 'a symbolizer = 'a -> string
  val create_scheme :
    next:(string -> string) -> string -> Graphlib.Std.Graphlib.scheme
  val symbols : Graphlib.Std.Graphlib.scheme
  val numbers : Graphlib.Std.Graphlib.scheme
  val nothing : Graphlib.Std.Graphlib.scheme
  val by_given_order :
    Graphlib.Std.Graphlib.scheme ->
    ('a -> 'a -> int) ->
    'a Core_kernel.Sequence.t -> 'a Graphlib.Std.Graphlib.symbolizer
  val by_natural_order :
    Graphlib.Std.Graphlib.scheme ->
    ('a -> 'a -> int) ->
    'a Core_kernel.Sequence.t -> 'a Graphlib.Std.Graphlib.symbolizer
  module Dot :
    sig
      val pp_graph :
        ?name:string ->
        ?attrs:string list ->
        ?string_of_node:'n Graphlib.Std.Graphlib.symbolizer ->
        ?node_label:'n Graphlib.Std.Graphlib.symbolizer ->
        ?edge_label:'e Graphlib.Std.Graphlib.symbolizer ->
        nodes_of_edge:('e -> 'n * 'n) ->
        nodes:'n Core_kernel.Sequence.t ->
        edges:'e Core_kernel.Sequence.t -> Format.formatter -> unit
    end
end